多用户网页直播平台:OBS/FFmpeg 鉴权 RTMP 推流到 SRS,HLS 低延迟播放; Fastify 5 + Prisma + PostgreSQL + Redis 后端,Vue 3 前端,Docker Compose 部署。
78 lines
21 KiB
TypeScript
78 lines
21 KiB
TypeScript
import type { FastifyInstance } from 'fastify';
|
|
import type { PrismaClient } from '@prisma/client';
|
|
import { createReadStream } from 'node:fs';
|
|
import { unlink } from 'node:fs/promises';
|
|
import { join } from 'node:path';
|
|
import type { RedisLike } from '../lib/redis.js';
|
|
import { z } from 'zod';
|
|
import si from 'systeminformation';
|
|
import type { AppConfig } from '../config.js';
|
|
import type { SettingsService } from './settings.service.js';
|
|
import type { MessagingService } from './messaging.service.js';
|
|
import { requireRoles } from '../lib/auth.js';
|
|
import { assert } from '../lib/errors.js';
|
|
import { stopSrsStream } from './rooms.routes.js';
|
|
import { hashPassword, validatePassword } from '../lib/password.js';
|
|
|
|
const admin = requireRoles('ADMIN', 'SUPER_ADMIN'); const superAdmin = requireRoles('SUPER_ADMIN');
|
|
const log = (db: PrismaClient, request: { auth?: { userId: string }; ip: string; id: string }, action: string, targetType?: string, targetId?: string, details?: object) => db.adminLog.create({ data: { adminId: request.auth!.userId, action, targetType, targetId, details, result: 'SUCCESS', ip: request.ip, requestId: request.id } });
|
|
|
|
export async function adminRoutes(app: FastifyInstance, deps: { db: PrismaClient; redis: RedisLike; config: AppConfig; settings: SettingsService; messaging: MessagingService }) {
|
|
const { db, redis, config, settings, messaging } = deps;
|
|
app.get('/api/admin/dashboard', { preHandler: admin }, async () => {
|
|
const start = new Date(); start.setHours(0, 0, 0, 0);
|
|
const [users, todayUsers, live, rooms, todaySessions, viewers, cpu, memory, fs] = await Promise.all([db.user.count(), db.user.count({ where: { createdAt: { gte: start } } }), db.room.count({ where: { streamStatus: 'LIVE' } }), db.room.count(), db.liveSession.count({ where: { startedAt: { gte: start } } }), db.room.aggregate({ _sum: { viewerCount: true } }), si.currentLoad(), si.mem(), si.fsSize()]);
|
|
const dbVersion = await db.$queryRaw<Array<{ version: string }>>`SELECT version()`; const redisInfo = await redis.info('server'); const redisVersion = /redis_version:([^\r\n]+)/.exec(redisInfo)?.[1] ?? 'unknown'; let mediaVersion='unavailable'; try { const response=await fetch(`${config.SRS_API_URL}/api/v1/versions`); if(response.ok){const body=await response.json() as {data?:{major?:number;minor?:number;revision?:number}};mediaVersion=body.data?`${body.data.major}.${body.data.minor}.${body.data.revision}`:'connected';} } catch {}
|
|
return { data: { metrics: { users, todayUsers, live, rooms, todaySessions, viewers: viewers._sum.viewerCount ?? 0 }, system: { node: process.version, postgres: dbVersion[0]?.version, redis: redisVersion, mediaServer: mediaVersion, platform: `${process.platform} ${process.arch}`, uptimeSeconds: Math.floor(process.uptime()), cpuUsage: Math.round(cpu.currentLoad * 10) / 10, memory: { total: memory.total, used: memory.active, free: memory.available }, disks: fs.map(x => ({ mount: x.mount, size: x.size, used: x.used, use: x.use })) } } };
|
|
});
|
|
|
|
app.get('/api/admin/health', { preHandler: admin }, async () => {
|
|
const result: Record<string, { status: string; detail?: string }> = { application: { status: '正常' } };
|
|
try { await db.$queryRaw`SELECT 1`; result.database={status:'正常'}; } catch { result.database={status:'异常'}; }
|
|
try { await redis.ping(); result.redis={status:'正常'}; } catch { result.redis={status:'异常'}; }
|
|
try { const r=await fetch(`${config.SRS_API_URL}/api/v1/versions`); result.mediaServer={status:r.ok?'正常':'异常'}; } catch { result.mediaServer={status:'异常'}; }
|
|
const all=await settings.all(false); result.smtp={status:all['smtp.host']?'已配置':'未配置'}; result.sms={status:all['sms.accessKeyId']?'已配置':'未配置'};
|
|
return { data: result };
|
|
});
|
|
|
|
app.get('/api/admin/users', { preHandler: admin }, async request => { const q = z.object({ search: z.string().optional(), page: z.coerce.number().default(1), limit: z.coerce.number().max(100).default(20) }).parse(request.query); const where = q.search ? { OR: [{ username: { contains: q.search, mode: 'insensitive' as const } }, { nickname: { contains: q.search, mode: 'insensitive' as const } }, { email: { contains: q.search, mode: 'insensitive' as const } }] } : {}; const [items, total] = await Promise.all([db.user.findMany({ where, select: { id: true, username: true, nickname: true, avatar: true, email: true, phone: true, status: true, canStream: true, registerIp: true, createdAt: true, lastLoginIp: true, lastLoginAt: true, roles: { select: { role: { select: { name: true } } } }, bans: { where: { revokedAt: null, OR: [{ expiresAt: null }, { expiresAt: { gt: new Date() } }] }, select: { id: true, type: true, reason: true, expiresAt: true } } }, skip: (q.page - 1) * q.limit, take: q.limit, orderBy: { createdAt: 'desc' } }), db.user.count({ where })]); return { data: items.map(u => ({ ...u, phone: u.phone ? `${u.phone.slice(0, 3)}****${u.phone.slice(-4)}` : null })), meta: { total } }; });
|
|
app.delete('/api/admin/users/:id', { preHandler: superAdmin }, async request => { const { id }=z.object({id:z.string().uuid()}).parse(request.params); assert(id!==request.auth!.userId,'CANNOT_DELETE_SELF','不能删除当前登录账号',409); await db.$transaction([db.refreshToken.updateMany({where:{userId:id},data:{revokedAt:new Date()}}),db.user.update({where:{id},data:{status:'DELETED',email:null,phone:null,canStream:false}})]); await log(db,request,'DELETE_USER','USER',id); return {data:{deleted:true}}; });
|
|
app.patch('/api/admin/users/:id', { preHandler: admin }, async request => { const { id } = z.object({ id: z.string().uuid() }).parse(request.params); const input = z.object({ status: z.enum(['ACTIVE', 'DISABLED']).optional(), canStream: z.boolean().optional(), nickname: z.string().min(1).max(64).optional() }).parse(request.body); const user = await db.user.update({ where: { id }, data: input }); if (input.canStream === false) { const rooms = await db.room.findMany({ where: { ownerId: id, streamStatus: 'LIVE' } }); await Promise.all(rooms.map(r => stopSrsStream(config, `room_${r.roomNumber}`))); } await log(db, request, 'UPDATE_USER', 'USER', id, input); return { data: user }; });
|
|
app.post('/api/admin/users/:id/reset-password', { preHandler: admin }, async request => { const { id } = z.object({ id: z.string().uuid() }).parse(request.params); const { password } = z.object({ password: z.string() }).parse(request.body); validatePassword(password, await settings.passwordPolicy()); await db.$transaction([db.user.update({ where: { id }, data: { passwordHash: await hashPassword(password) } }), db.refreshToken.updateMany({ where: { userId: id }, data: { revokedAt: new Date() } })]); await log(db, request, 'RESET_USER_PASSWORD', 'USER', id); return { data: { reset: true } }; });
|
|
app.post('/api/admin/users/:id/chat-ban', { preHandler: admin }, async request => { const {id}=z.object({id:z.string().uuid()}).parse(request.params); const input=z.object({minutes:z.number().int().min(1).max(525600).default(60),reason:z.string().max(500).optional()}).parse(request.body); const ban=await db.ban.create({data:{userId:id,type:'CHAT',reason:input.reason,expiresAt:new Date(Date.now()+input.minutes*60000),createdBy:request.auth!.userId}}); await log(db,request,'MUTE_USER','USER',id,{minutes:input.minutes}); return {data:ban}; });
|
|
app.delete('/api/admin/bans/:id', { preHandler: admin }, async request => { const {id}=z.object({id:z.string().uuid()}).parse(request.params); const ban=await db.ban.update({where:{id},data:{revokedAt:new Date()}}); await log(db,request,'REVOKE_BAN','BAN',id); return {data:ban}; });
|
|
|
|
app.get('/api/admin/rooms', { preHandler: admin }, async () => ({ data: await db.room.findMany({ include: { owner: { select: { id: true, username: true, nickname: true, avatar: true } }, category: true }, orderBy: { updatedAt: 'desc' } }) }));
|
|
app.patch('/api/admin/rooms/:roomNumber', { preHandler: admin }, async request => { const {roomNumber}=z.object({roomNumber:z.coerce.number()}).parse(request.params); const input=z.object({featured:z.boolean().optional(),visibility:z.enum(['PUBLIC','PRIVATE']).optional(),title:z.string().min(1).max(120).optional()}).parse(request.body); const room=await db.room.update({where:{roomNumber},data:input}); await log(db,request,'UPDATE_ROOM','ROOM',String(roomNumber),input); return {data:room}; });
|
|
app.delete('/api/admin/rooms/:roomNumber', { preHandler: admin }, async request => { const {roomNumber}=z.object({roomNumber:z.coerce.number()}).parse(request.params); const room=await db.room.findUnique({where:{roomNumber}}); assert(room,'ROOM_NOT_FOUND','直播间不存在',404); if(room.streamStatus==='LIVE')await stopSrsStream(config,`room_${roomNumber}`); await db.room.delete({where:{id:room.id}}); await log(db,request,'DELETE_ROOM','ROOM',String(roomNumber)); return {data:{deleted:true}}; });
|
|
app.get('/api/admin/sessions', { preHandler: admin }, async () => ({ data: await db.liveSession.findMany({ take: 200, orderBy: { startedAt: 'desc' }, select: { id: true, startedAt: true, endedAt: true, durationSeconds: true, peakViewers: true, totalViews: true, recordingUrl: true, room: { select: { roomNumber: true, title: true, owner: { select: { nickname: true } } } } } }) }));
|
|
app.get('/api/admin/messages', { preHandler: admin }, async () => ({ data: await db.chatMessage.findMany({ take: 200, orderBy: { createdAt: 'desc' }, include: { room: { select: { roomNumber: true, title: true } } } }) }));
|
|
app.get('/api/admin/notices', { preHandler: admin }, async () => ({ data: await db.notice.findMany({ take: 200, orderBy: { createdAt: 'desc' }, include: { from: { select: { id: true, username: true, nickname: true } } } }) }));
|
|
app.post('/api/admin/notices/:id/approve', { preHandler: admin }, async request => { const { id } = z.object({ id: z.string().uuid() }).parse(request.params); const notice = await db.notice.findUnique({ where: { id } }); assert(notice, 'NOTICE_NOT_FOUND', '申请不存在', 404); assert(notice.status === 'PENDING', 'NOTICE_ALREADY_HANDLED', '该申请已处理'); await db.$transaction([db.notice.update({ where: { id }, data: { status: 'APPROVED', handledAt: new Date(), handledBy: request.auth!.userId } }), db.user.update({ where: { id: notice.fromId }, data: { canStream: true } })]); await log(db, request, 'APPROVE_STREAM_PERMISSION', 'NOTICE', id); return { data: { approved: true } }; });
|
|
app.post('/api/admin/notices/:id/reject', { preHandler: admin }, async request => { const { id } = z.object({ id: z.string().uuid() }).parse(request.params); const notice = await db.notice.findUnique({ where: { id } }); assert(notice, 'NOTICE_NOT_FOUND', '申请不存在', 404); assert(notice.status === 'PENDING', 'NOTICE_ALREADY_HANDLED', '该申请已处理'); await db.notice.update({ where: { id }, data: { status: 'REJECTED', handledAt: new Date(), handledBy: request.auth!.userId } }); await log(db, request, 'REJECT_STREAM_PERMISSION', 'NOTICE', id); return { data: { rejected: true } }; });
|
|
app.get('/api/admin/files', { preHandler: admin }, async request => { const q = z.object({ page: z.coerce.number().default(1), limit: z.coerce.number().max(100).default(100) }).parse(request.query); const [items, total] = await Promise.all([db.upload.findMany({ include: { uploader: { select: { id: true, nickname: true } } }, skip: (q.page - 1) * q.limit, take: q.limit, orderBy: { createdAt: 'desc' } }), db.upload.count()]); return { data: items, meta: { total } }; });
|
|
app.delete('/api/admin/files/:id', { preHandler: admin }, async request => { const { id } = z.object({ id: z.string().uuid() }).parse(request.params); const file = await db.upload.findUnique({ where: { id } }); assert(file, 'FILE_NOT_FOUND', '文件不存在', 404); await unlink(join(config.UPLOAD_DIR, file.filename)).catch(error => request.log.error({ err: error }, 'delete upload file failed')); await db.upload.delete({ where: { id } }); await log(db, request, 'DELETE_UPLOAD', 'UPLOAD', id, { filename: file.filename }); return { data: { deleted: true } }; });
|
|
app.get('/api/admin/files/:id/download', { preHandler: admin }, async (request, reply) => { const { id } = z.object({ id: z.string().uuid() }).parse(request.params); const file = await db.upload.findUnique({ where: { id } }); assert(file, 'FILE_NOT_FOUND', '文件不存在', 404); const name = (file.originalName ?? file.filename).replace(/["\\\r\n]/g, '_'); reply.header('content-disposition', `attachment; filename*=UTF-8''${encodeURIComponent(name)}`).type(file.mimeType); return reply.send(createReadStream(join(config.UPLOAD_DIR, file.filename))); });
|
|
app.get('/api/admin/replays', { preHandler: admin }, async request => { const q = z.object({ page: z.coerce.number().default(1), limit: z.coerce.number().max(100).default(100) }).parse(request.query); const [items, total] = await Promise.all([db.liveSession.findMany({ where: { recordingUrl: { not: null } }, skip: (q.page - 1) * q.limit, take: q.limit, orderBy: { startedAt: 'desc' }, select: { id: true, startedAt: true, endedAt: true, durationSeconds: true, peakViewers: true, totalViews: true, recordingUrl: true, recordingSize: true, room: { select: { roomNumber: true, title: true, owner: { select: { nickname: true } } } } } }), db.liveSession.count({ where: { recordingUrl: { not: null } } })]); return { data: items.map(s => ({ ...s, recordingSize: s.recordingSize?.toString() ?? null })), meta: { total } }; });
|
|
app.delete('/api/admin/replays/:id', { preHandler: admin }, async request => { const { id } = z.object({ id: z.string().uuid() }).parse(request.params); const session = await db.liveSession.findUnique({ where: { id } }); assert(session?.recordingUrl, 'REPLAY_NOT_FOUND', '该场次没有回放', 404); const fileName = session.recordingUrl.split(/[\\/]/).pop(); if (fileName && /^room_\d+\.\d+\.flv$/.test(fileName)) await unlink(join(config.LIVE_DIR, 'replays', fileName)).catch(error => request.log.error({ err: error }, 'delete replay file failed')); await db.liveSession.update({ where: { id }, data: { recordingUrl: null, recordingSize: null } }); await log(db, request, 'DELETE_REPLAY', 'SESSION', id, { file: fileName }); return { data: { deleted: true } }; });
|
|
app.get('/api/admin/replays/:id/download', { preHandler: admin }, async (request, reply) => { const { id } = z.object({ id: z.string().uuid() }).parse(request.params); const session = await db.liveSession.findUnique({ where: { id } }); assert(session?.recordingUrl, 'REPLAY_NOT_FOUND', '该场次没有回放', 404); const fileName = session.recordingUrl.split(/[\\/]/).pop(); assert(fileName && /^room_\d+\.\d+\.flv$/.test(fileName), 'RECORDING_PATH_INVALID', '回放文件路径无效', 422); reply.header('content-disposition', `attachment; filename="${fileName}"`).type('video/x-flv'); return reply.send(createReadStream(join(config.LIVE_DIR, 'replays', fileName))); });
|
|
app.post('/api/admin/rooms/:roomNumber/stop', { preHandler: admin }, async request => { const { roomNumber } = z.object({ roomNumber: z.coerce.number() }).parse(request.params); const room = await db.room.findUnique({ where: { roomNumber } }); assert(room, 'ROOM_NOT_FOUND', '直播间不存在', 404); const stopped = await stopSrsStream(config, `room_${roomNumber}`); await db.room.update({ where: { id: room.id }, data: { streamStatus: 'OFFLINE', viewerCount: 0 } }); await log(db, request, 'FORCE_STOP_STREAM', 'ROOM', String(roomNumber), { stopped }); return { data: { stopped } }; });
|
|
app.post('/api/admin/rooms/:roomNumber/ban', { preHandler: admin }, async request => { const { roomNumber } = z.object({ roomNumber: z.coerce.number() }).parse(request.params); const room = await db.room.update({ where: { roomNumber }, data: { liveBanned: true, streamStatus: 'BANNED' } }); await stopSrsStream(config, `room_${roomNumber}`); await log(db, request, 'BAN_ROOM_STREAM', 'ROOM', String(roomNumber)); return { data: room }; });
|
|
app.post('/api/admin/rooms/:roomNumber/unban', { preHandler: admin }, async request => { const { roomNumber } = z.object({ roomNumber: z.coerce.number() }).parse(request.params); const room = await db.room.update({ where: { roomNumber }, data: { liveBanned: false, streamStatus: 'OFFLINE' } }); await log(db, request, 'UNBAN_ROOM_STREAM', 'ROOM', String(roomNumber)); return { data: room }; });
|
|
|
|
app.get('/api/admin/categories', { preHandler: admin }, async () => ({ data: await db.category.findMany({ orderBy: [{ sort: 'asc' }, { id: 'asc' }] }) }));
|
|
app.post('/api/admin/categories', { preHandler: admin }, async (request, reply) => { const input = z.object({ name: z.string().min(1).max(64), slug: z.string().regex(/^[a-z0-9-]+$/), icon: z.string().max(128).optional(), sort: z.number().int().default(0), enabled: z.boolean().default(true) }).parse(request.body); const item = await db.category.create({ data: input }); await log(db, request, 'CREATE_CATEGORY', 'CATEGORY', String(item.id)); reply.code(201).send({ data: item }); });
|
|
app.patch('/api/admin/categories/:id', { preHandler: admin }, async request => { const { id } = z.object({ id: z.coerce.number() }).parse(request.params); const input = z.object({ name: z.string().min(1).max(64), slug: z.string().regex(/^[a-z0-9-]+$/), icon: z.string().max(128).nullable(), sort: z.number().int(), enabled: z.boolean() }).partial().parse(request.body); const item = await db.category.update({ where: { id }, data: input }); await log(db, request, 'UPDATE_CATEGORY', 'CATEGORY', String(id)); return { data: item }; });
|
|
app.delete('/api/admin/categories/:id', { preHandler: admin }, async request => { const { id } = z.object({ id: z.coerce.number() }).parse(request.params); assert(await db.room.count({ where: { categoryId: id } }) === 0, 'CATEGORY_IN_USE', '该分类下仍有直播间,不能删除', 409); await db.category.delete({ where: { id } }); await log(db, request, 'DELETE_CATEGORY', 'CATEGORY', String(id)); return { data: { deleted: true } }; });
|
|
|
|
app.get('/api/admin/settings', { preHandler: admin }, async () => ({ data: await settings.all(false) }));
|
|
app.put('/api/admin/settings', { preHandler: superAdmin }, async request => { const { values } = z.object({ values: z.record(z.string(), z.unknown()) }).parse(request.body); await settings.setMany(values, request.auth!.userId); await log(db, request, 'UPDATE_SETTINGS', 'SYSTEM', 'settings', { keys: Object.keys(values) }); return { data: await settings.all(false) }; });
|
|
app.post('/api/admin/settings/smtp/test', { preHandler: superAdmin }, async request => { const { email } = z.object({ email: z.string().email() }).parse(request.body); const info = await messaging.sendEmail(email, 'XLive SMTP 测试', '如果您收到此邮件,说明 XLive SMTP 配置有效。'); await log(db, request, 'TEST_SMTP', 'SYSTEM', 'smtp', { accepted: info.accepted }); return { data: { sent: true, accepted: info.accepted } }; });
|
|
app.post('/api/admin/settings/sms/test', { preHandler: superAdmin }, async request => { const { phone } = z.object({ phone: z.string().regex(/^\+?\d{7,15}$/) }).parse(request.body); const code = String(Math.floor(100000 + Math.random() * 900000)); const result = await messaging.sendSmsForPurpose(phone, 'REGISTER', code); await log(db, request, 'TEST_SMS', 'SYSTEM', 'sms', { requestId: result.RequestId }); return { data: { sent: true, requestId: result.RequestId } }; });
|
|
app.get('/api/admin/logs', { preHandler: admin }, async () => ({ data: (await db.adminLog.findMany({ take: 200, orderBy: { createdAt: 'desc' }, include: { admin: { select: { username: true, nickname: true } } } })).map(item => ({ ...item, id: item.id.toString() })) }));
|
|
app.get('/api/admin/admins', { preHandler: superAdmin }, async () => ({ data: await db.user.findMany({ where: { roles: { some: { role: { name: { in: ['ADMIN','SUPER_ADMIN'] } } } } }, select: { id:true,username:true,nickname:true,email:true,status:true,createdAt:true,roles:{select:{role:{select:{name:true}}}} }, orderBy:{createdAt:'asc'} }) }));
|
|
app.patch('/api/admin/admins/:id/role', { preHandler: superAdmin }, async request => { const {id}=z.object({id:z.string().uuid()}).parse(request.params); const {role}=z.object({role:z.enum(['ADMIN','SUPER_ADMIN'])}).parse(request.body); assert(id!==request.auth!.userId,'CANNOT_CHANGE_SELF_ROLE','不能修改当前登录账号的角色',409); const target=await db.user.findUnique({where:{id}}); assert(target,'USER_NOT_FOUND','用户不存在',404); await db.$transaction(async tx=>{const selectedRole=await tx.role.findUniqueOrThrow({where:{name:role}}); await tx.userRole.deleteMany({where:{userId:id,role:{name:{in:['ADMIN','SUPER_ADMIN']}}}}); await tx.userRole.create({data:{userId:id,roleId:selectedRole.id}})}); await log(db,request,'CHANGE_ADMIN_ROLE','USER',id,{role}); return {data:{updated:true}}; });
|
|
app.delete('/api/admin/messages/:id', { preHandler: admin }, async request => { const { id } = z.object({ id: z.string().uuid() }).parse(request.params); await db.chatMessage.update({ where: { id }, data: { deletedAt: new Date(), deletedBy: request.auth!.userId } }); await log(db, request, 'DELETE_CHAT_MESSAGE', 'CHAT_MESSAGE', id); return { data: { deleted: true } }; });
|
|
app.post('/api/admin/admins', { preHandler: superAdmin }, async (request, reply) => { const input = z.object({ username: z.string().min(3).max(32), nickname: z.string().min(1).max(64), email: z.string().email(), password: z.string(), role: z.enum(['ADMIN', 'SUPER_ADMIN']).default('ADMIN') }).parse(request.body); validatePassword(input.password, await settings.passwordPolicy()); const user = await db.user.create({ data: { username: input.username, nickname: input.nickname, email: input.email.toLowerCase(), passwordHash: await hashPassword(input.password), roles: { create: { role: { connect: { name: input.role } } } } } }); await log(db, request, 'CREATE_ADMIN', 'USER', user.id, { role: input.role }); reply.code(201).send({ data: { id: user.id } }); });
|
|
}
|