540 lines
17 KiB
TypeScript
540 lines
17 KiB
TypeScript
import { createError, defineEventHandler, readBody } from 'h3'
|
|
import { db } from '~/drizzle/db'
|
|
import {
|
|
apiKeys,
|
|
apiKeyPermissions,
|
|
apiLogs,
|
|
collaborationLogs,
|
|
emailTemplates,
|
|
notifications,
|
|
notificationSettings,
|
|
playTimes,
|
|
requestTimes,
|
|
schedules,
|
|
semesters,
|
|
songBlacklists,
|
|
songCollaborators,
|
|
songReplayRequests,
|
|
songs,
|
|
systemSettings,
|
|
users,
|
|
userIdentities,
|
|
userStatusLogs,
|
|
votes
|
|
} from '~/drizzle/schema'
|
|
import { promises as fs } from 'fs'
|
|
import path from 'path'
|
|
|
|
export default defineEventHandler(async (event) => {
|
|
try {
|
|
// 验证管理员权限
|
|
const user = event.context.user
|
|
if (!user || !['ADMIN', 'SUPER_ADMIN'].includes(user.role)) {
|
|
throw createError({
|
|
statusCode: 403,
|
|
statusMessage: '权限不足'
|
|
})
|
|
}
|
|
|
|
const body = await readBody(event)
|
|
const { tables = 'all', includeSystemData = true } = body
|
|
|
|
console.log('开始创建数据库备份...')
|
|
|
|
// 创建备份数据对象
|
|
const backupData = {
|
|
metadata: {
|
|
version: '1.0',
|
|
timestamp: new Date().toISOString(),
|
|
creator: user.username,
|
|
description: '',
|
|
backupType: 'custom',
|
|
tables: [],
|
|
totalRecords: 0
|
|
},
|
|
data: {}
|
|
}
|
|
|
|
// 定义要备份的表和对应的查询
|
|
const tablesToBackup = {
|
|
users: {
|
|
query: async () => {
|
|
const usersData = await db.select().from(users)
|
|
const settingsData = await db.select().from(notificationSettings)
|
|
|
|
// 手动关联通知设置
|
|
return usersData.map((user) => ({
|
|
...user,
|
|
notificationSettings: settingsData.filter((setting) => setting.userId === user.id)
|
|
}))
|
|
},
|
|
description: '用户数据'
|
|
},
|
|
songs: {
|
|
query: async () => {
|
|
const songsData = await db.select().from(songs)
|
|
const usersData = await db
|
|
.select({
|
|
id: users.id,
|
|
username: users.username,
|
|
name: users.name
|
|
})
|
|
.from(users)
|
|
const votesData = await db.select().from(votes)
|
|
const schedulesData = await db.select().from(schedules)
|
|
const playTimesData = await db.select().from(playTimes)
|
|
|
|
// 手动关联数据
|
|
return songsData.map((song) => ({
|
|
...song,
|
|
requester: usersData.find((user) => user.id === song.requesterId),
|
|
votes: votesData
|
|
.filter((vote) => vote.songId === song.id)
|
|
.map((vote) => ({
|
|
...vote,
|
|
user: usersData.find((user) => user.id === vote.userId)
|
|
})),
|
|
schedules: schedulesData.filter((schedule) => schedule.songId === song.id),
|
|
preferredPlayTime: playTimesData.find((pt) => pt.id === song.preferredPlayTimeId)
|
|
}))
|
|
},
|
|
description: '歌曲数据'
|
|
},
|
|
votes: {
|
|
query: async () => {
|
|
const votesData = await db.select().from(votes)
|
|
const usersData = await db
|
|
.select({
|
|
id: users.id,
|
|
username: users.username,
|
|
name: users.name
|
|
})
|
|
.from(users)
|
|
const songsData = await db
|
|
.select({
|
|
id: songs.id,
|
|
title: songs.title,
|
|
artist: songs.artist
|
|
})
|
|
.from(songs)
|
|
|
|
return votesData.map((vote) => ({
|
|
...vote,
|
|
user: usersData.find((user) => user.id === vote.userId),
|
|
song: songsData.find((song) => song.id === vote.songId)
|
|
}))
|
|
},
|
|
description: '投票数据'
|
|
},
|
|
schedules: {
|
|
query: async () => {
|
|
const schedulesData = await db.select().from(schedules)
|
|
const songsData = await db
|
|
.select({
|
|
id: songs.id,
|
|
title: songs.title,
|
|
artist: songs.artist
|
|
})
|
|
.from(songs)
|
|
const playTimesData = await db.select().from(playTimes)
|
|
|
|
return schedulesData.map((schedule) => ({
|
|
...schedule,
|
|
song: songsData.find((song) => song.id === schedule.songId),
|
|
playTime: playTimesData.find((pt) => pt.id === schedule.playTimeId)
|
|
}))
|
|
},
|
|
description: '排期数据'
|
|
},
|
|
notifications: {
|
|
query: async () => {
|
|
const notificationsData = await db.select().from(notifications)
|
|
const usersData = await db
|
|
.select({
|
|
id: users.id,
|
|
username: users.username,
|
|
name: users.name
|
|
})
|
|
.from(users)
|
|
const songsData = await db
|
|
.select({
|
|
id: songs.id,
|
|
title: songs.title,
|
|
artist: songs.artist
|
|
})
|
|
.from(songs)
|
|
|
|
return notificationsData.map((notification) => ({
|
|
...notification,
|
|
user: usersData.find((user) => user.id === notification.userId),
|
|
song: notification.songId
|
|
? songsData.find((song) => song.id === notification.songId)
|
|
: null
|
|
}))
|
|
},
|
|
description: '通知数据'
|
|
},
|
|
notificationSettings: {
|
|
query: async () => {
|
|
const settingsData = await db.select().from(notificationSettings)
|
|
const usersData = await db
|
|
.select({
|
|
id: users.id,
|
|
username: users.username,
|
|
name: users.name
|
|
})
|
|
.from(users)
|
|
|
|
return settingsData.map((setting) => ({
|
|
...setting,
|
|
user: usersData.find((user) => user.id === setting.userId)
|
|
}))
|
|
},
|
|
description: '通知设置'
|
|
},
|
|
playTimes: {
|
|
query: () => db.select().from(playTimes),
|
|
description: '播出时段'
|
|
},
|
|
semesters: {
|
|
query: () => db.select().from(semesters),
|
|
description: '学期数据'
|
|
},
|
|
songBlacklist: {
|
|
query: () => db.select().from(songBlacklists),
|
|
description: '歌曲黑名单'
|
|
},
|
|
userStatusLogs: {
|
|
query: async () => {
|
|
const statusLogsData = await db.select().from(userStatusLogs)
|
|
const usersData = await db
|
|
.select({
|
|
id: users.id,
|
|
username: users.username,
|
|
name: users.name
|
|
})
|
|
.from(users)
|
|
|
|
return statusLogsData.map((log) => ({
|
|
...log,
|
|
user: usersData.find((user) => user.id === log.userId)
|
|
}))
|
|
},
|
|
description: '用户状态变更日志'
|
|
},
|
|
userIdentities: {
|
|
query: async () => {
|
|
const identitiesData = await db.select().from(userIdentities)
|
|
const usersData = await db
|
|
.select({
|
|
id: users.id,
|
|
username: users.username,
|
|
name: users.name
|
|
})
|
|
.from(users)
|
|
|
|
return identitiesData.map((identity) => ({
|
|
...identity,
|
|
user: usersData.find((user) => user.id === identity.userId)
|
|
}))
|
|
},
|
|
description: '第三方身份关联'
|
|
},
|
|
songCollaborators: {
|
|
query: async () => {
|
|
const collaboratorsData = await db.select().from(songCollaborators)
|
|
return collaboratorsData
|
|
},
|
|
description: '联合投稿人'
|
|
},
|
|
collaborationLogs: {
|
|
query: async () => {
|
|
const logsData = await db.select().from(collaborationLogs)
|
|
return logsData
|
|
},
|
|
description: '联合投稿审计日志'
|
|
},
|
|
songReplayRequests: {
|
|
query: async () => {
|
|
const requestsData = await db.select().from(songReplayRequests)
|
|
const usersData = await db
|
|
.select({
|
|
id: users.id,
|
|
username: users.username,
|
|
name: users.name
|
|
})
|
|
.from(users)
|
|
const songsData = await db
|
|
.select({
|
|
id: songs.id,
|
|
title: songs.title,
|
|
artist: songs.artist
|
|
})
|
|
.from(songs)
|
|
|
|
return requestsData.map((req) => ({
|
|
...req,
|
|
user: usersData.find((user) => user.id === req.userId),
|
|
song: songsData.find((song) => song.id === req.songId)
|
|
}))
|
|
},
|
|
description: '歌曲重播申请'
|
|
},
|
|
apiKeys: {
|
|
query: async () => {
|
|
const apiKeysData = await db.select().from(apiKeys)
|
|
const usersData = await db
|
|
.select({
|
|
id: users.id,
|
|
username: users.username,
|
|
name: users.name
|
|
})
|
|
.from(users)
|
|
const permissionsData = await db.select().from(apiKeyPermissions)
|
|
|
|
return apiKeysData.map((key) => ({
|
|
...key,
|
|
createdByUser: usersData.find((user) => user.id === key.createdByUserId),
|
|
permissions: permissionsData.filter((perm) => perm.apiKeyId === key.id)
|
|
}))
|
|
},
|
|
description: 'API密钥'
|
|
},
|
|
apiKeyPermissions: {
|
|
query: () => db.select().from(apiKeyPermissions),
|
|
description: 'API密钥权限'
|
|
},
|
|
apiLogs: {
|
|
query: async () => {
|
|
const logsData = await db.select().from(apiLogs)
|
|
const apiKeysData = await db
|
|
.select({
|
|
id: apiKeys.id,
|
|
name: apiKeys.name
|
|
})
|
|
.from(apiKeys)
|
|
|
|
return logsData.map((log) => ({
|
|
...log,
|
|
apiKey: log.apiKeyId ? apiKeysData.find((key) => key.id === log.apiKeyId) : null
|
|
}))
|
|
},
|
|
description: 'API访问日志'
|
|
},
|
|
emailTemplates: {
|
|
query: async () => {
|
|
const templatesData = await db.select().from(emailTemplates)
|
|
const usersData = await db
|
|
.select({
|
|
id: users.id,
|
|
username: users.username,
|
|
name: users.name
|
|
})
|
|
.from(users)
|
|
|
|
return templatesData.map((template) => ({
|
|
...template,
|
|
updatedByUser: template.updatedByUserId
|
|
? usersData.find((user) => user.id === template.updatedByUserId)
|
|
: null
|
|
}))
|
|
},
|
|
description: '邮件模板'
|
|
},
|
|
requestTimes: {
|
|
query: () => db.select().from(requestTimes),
|
|
description: '请求时段'
|
|
}
|
|
}
|
|
|
|
// 如果包含系统数据，添加系统设置表
|
|
if (includeSystemData) {
|
|
tablesToBackup.systemSettings = {
|
|
query: () => db.select().from(systemSettings),
|
|
description: '系统设置'
|
|
}
|
|
}
|
|
|
|
// 根据请求的表进行备份
|
|
let tablesToProcess
|
|
if (tables === 'all') {
|
|
tablesToProcess = Object.keys(tablesToBackup)
|
|
} else if (tables === 'users') {
|
|
// 仅备份用户相关数据
|
|
tablesToProcess = ['users', 'notificationSettings', 'userStatusLogs', 'userIdentities']
|
|
// 如果包含系统数据，也添加到处理列表中
|
|
if (includeSystemData) {
|
|
tablesToProcess.push('systemSettings')
|
|
}
|
|
} else if (Array.isArray(tables)) {
|
|
tablesToProcess = tables
|
|
} else {
|
|
tablesToProcess = [tables]
|
|
}
|
|
|
|
if (
|
|
includeSystemData &&
|
|
tablesToBackup.systemSettings &&
|
|
!tablesToProcess.includes('systemSettings')
|
|
) {
|
|
tablesToProcess.push('systemSettings')
|
|
}
|
|
|
|
if (tablesToProcess.length === 1 && tablesToProcess[0] === 'systemSettings') {
|
|
backupData.metadata.backupType = 'system'
|
|
backupData.metadata.description = `系统配置备份 - ${new Date().toLocaleString('zh-CN')}`
|
|
} else if (tables === 'users') {
|
|
backupData.metadata.backupType = 'users'
|
|
backupData.metadata.description = `用户数据备份 - ${new Date().toLocaleString('zh-CN')}`
|
|
} else if (tables === 'all') {
|
|
backupData.metadata.backupType = 'full'
|
|
backupData.metadata.description = `完整数据库备份 - ${new Date().toLocaleString('zh-CN')}`
|
|
} else if (tables === 'songs') {
|
|
backupData.metadata.backupType = 'songs'
|
|
backupData.metadata.description = `歌曲数据备份 - ${new Date().toLocaleString('zh-CN')}`
|
|
} else {
|
|
backupData.metadata.description = `自定义数据库备份 - ${new Date().toLocaleString('zh-CN')}`
|
|
}
|
|
|
|
let totalRecords = 0
|
|
|
|
for (const tableName of tablesToProcess) {
|
|
if (!tablesToBackup[tableName]) {
|
|
console.warn(`未知的表名: ${tableName}`)
|
|
continue
|
|
}
|
|
|
|
try {
|
|
console.log(`备份表: ${tableName}`)
|
|
const tableData = await tablesToBackup[tableName].query()
|
|
|
|
backupData.data[tableName] = tableData
|
|
backupData.metadata.tables.push({
|
|
name: tableName,
|
|
description: tablesToBackup[tableName].description,
|
|
recordCount: tableData.length
|
|
})
|
|
|
|
totalRecords += tableData.length
|
|
console.log(`✅ ${tableName}: ${tableData.length} 条记录`)
|
|
} catch (error) {
|
|
// 检查是否为表不存在错误
|
|
// Postgres 错误代码 42P01: undefined_table (表不存在)
|
|
const isTableMissing =
|
|
error.code === '42P01' ||
|
|
(error.message && error.message.includes('does not exist')) ||
|
|
(error.statusMessage && error.statusMessage.includes('does not exist'))
|
|
|
|
if (isTableMissing) {
|
|
console.warn(`⚠️ 表 ${tableName} 不存在，跳过备份`)
|
|
// 记录一个空的条目，以便知道跳过了
|
|
backupData.metadata.tables.push({
|
|
name: tableName,
|
|
description: `${tablesToBackup[tableName].description} (表不存在，已跳过)`,
|
|
recordCount: 0,
|
|
skipped: true
|
|
})
|
|
continue
|
|
}
|
|
|
|
console.error(`备份表 ${tableName} 失败:`, error)
|
|
throw createError({
|
|
statusCode: 500,
|
|
statusMessage: `备份表 ${tableName} 失败: ${error.message}`
|
|
})
|
|
}
|
|
}
|
|
|
|
backupData.metadata.totalRecords = totalRecords
|
|
|
|
// 生成备份文件名（用于下载）
|
|
const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
|
|
let filePrefix = 'database-backup'
|
|
|
|
if (tables === 'users') {
|
|
filePrefix = includeSystemData ? 'users-system-backup' : 'users-backup'
|
|
} else if (tablesToProcess.length === 1 && tablesToProcess[0] === 'systemSettings') {
|
|
filePrefix = 'system-settings-backup'
|
|
} else if (tables === 'songs') {
|
|
filePrefix = includeSystemData ? 'songs-system-backup' : 'songs-backup'
|
|
}
|
|
|
|
const filename = `${filePrefix}-${timestamp}.json`
|
|
|
|
console.log(`✅ 备份完成: ${filename}`)
|
|
console.log(`📊 总计备份 ${totalRecords} 条记录`)
|
|
|
|
// 检测运行环境
|
|
const isVercel = process.env.VERCEL || process.env.VERCEL_ENV
|
|
const isNetlify = process.env.NETLIFY
|
|
const isServerless = isVercel || isNetlify
|
|
|
|
if (isServerless) {
|
|
// 在无服务器环境中，直接返回备份数据供前端下载
|
|
console.log('🌐 检测到无服务器环境，直接返回备份数据')
|
|
|
|
// 计算数据大小（估算）
|
|
const dataSize = JSON.stringify(backupData).length
|
|
|
|
return {
|
|
success: true,
|
|
message: '数据库备份创建成功',
|
|
backup: {
|
|
filename,
|
|
data: backupData,
|
|
size: dataSize,
|
|
metadata: backupData.metadata,
|
|
downloadMode: 'direct' // 标识为直接下载模式
|
|
}
|
|
}
|
|
} else {
|
|
// 在传统服务器环境中，保存到文件系统
|
|
try {
|
|
const backupDir = path.join(process.cwd(), 'backups')
|
|
try {
|
|
await fs.access(backupDir)
|
|
} catch {
|
|
await fs.mkdir(backupDir, { recursive: true })
|
|
}
|
|
|
|
const filepath = path.join(backupDir, filename)
|
|
await fs.writeFile(filepath, JSON.stringify(backupData, null, 2), 'utf8')
|
|
|
|
return {
|
|
success: true,
|
|
message: '数据库备份创建成功',
|
|
backup: {
|
|
filename,
|
|
filepath,
|
|
size: (await fs.stat(filepath)).size,
|
|
metadata: backupData.metadata,
|
|
downloadMode: 'file' // 标识为文件下载模式
|
|
}
|
|
}
|
|
} catch (fsError) {
|
|
console.warn('文件系统操作失败，回退到直接返回模式:', fsError.message)
|
|
|
|
// 如果文件系统操作失败，回退到直接返回模式
|
|
const dataSize = JSON.stringify(backupData).length
|
|
return {
|
|
success: true,
|
|
message: '数据库备份创建成功（直接下载模式）',
|
|
backup: {
|
|
filename,
|
|
data: backupData,
|
|
size: dataSize,
|
|
metadata: backupData.metadata,
|
|
downloadMode: 'direct'
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} catch (error) {
|
|
console.error('创建数据库备份失败:', error)
|
|
throw createError({
|
|
statusCode: error.statusCode || 500,
|
|
statusMessage: error.statusMessage || '创建数据库备份失败'
|
|
})
|
|
}
|
|
})
|