952 lines
43 KiB
TypeScript
952 lines
43 KiB
TypeScript
import { NextFunction, Request, Response, Router } from 'express';
|
|
import { prisma } from '../../database/index';
|
|
import { settingsStore } from '../../config/state';
|
|
import { context } from '../../config/context';
|
|
import { LoggingService } from '../../services/loggingService';
|
|
import { env } from '../../config/env';
|
|
|
|
const router = Router();
|
|
const moduleService = context.modules;
|
|
|
|
function requireAuth(req: Request, res: Response, next: NextFunction) {
|
|
if (!req.session?.user) {
|
|
return res.status(401).json({ error: 'unauthorized', login: '/auth/discord' });
|
|
}
|
|
next();
|
|
}
|
|
|
|
function requireAdmin(req: Request, res: Response, next: NextFunction) {
|
|
const userId = req.session?.user?.id;
|
|
const allowed = Array.isArray(env.ownerIds) ? env.ownerIds.filter(Boolean) : [];
|
|
if (!userId || !allowed.includes(userId)) {
|
|
return res.status(403).json({ error: 'forbidden' });
|
|
}
|
|
next();
|
|
}
|
|
|
|
router.get('/me', requireAuth, (req, res) => {
|
|
const allowed = Array.isArray(env.ownerIds) ? env.ownerIds.filter(Boolean) : [];
|
|
const isAdmin = !!req.session.user && allowed.includes(req.session.user.id);
|
|
res.json({ user: { ...req.session.user, isAdmin } });
|
|
});
|
|
|
|
router.get('/guilds', requireAuth, (req, res) => {
|
|
const sessionGuilds = Array.isArray(req.session?.guilds) ? req.session.guilds : [];
|
|
// Only allow guilds the user owns or can manage (manage_guild or admin) and where the bot is present
|
|
const allowedIds = new Set(
|
|
sessionGuilds
|
|
.filter((g: any) => {
|
|
if (!g) return false;
|
|
if (g.owner) return true;
|
|
const perms = g.permissions ? BigInt(g.permissions) : 0n;
|
|
const hasAdmin = (perms & 0x8n) === 0x8n;
|
|
const hasManageGuild = (perms & 0x20n) === 0x20n;
|
|
return hasAdmin || hasManageGuild;
|
|
})
|
|
.map((g: any) => g.id)
|
|
);
|
|
const guilds =
|
|
context.client?.guilds.cache
|
|
.filter((g) => allowedIds.has(g.id))
|
|
.map((g) => ({
|
|
id: g.id,
|
|
name: g.name,
|
|
icon: g.icon
|
|
})) ?? [];
|
|
res.json({ guilds });
|
|
});
|
|
|
|
router.get('/guild/info', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.query.guildId === 'string' ? req.query.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const guild =
|
|
context.client?.guilds.cache.get(guildId) || (await context.client?.guilds.fetch(guildId).catch(() => null));
|
|
if (!guild) return res.status(404).json({ error: 'guild not found' });
|
|
const owner = await guild.fetchOwner().catch(() => null);
|
|
const channels = guild.channels.cache;
|
|
const textCount = channels.filter((c) => c.isTextBased()).size;
|
|
const voiceCount = channels.filter((c) => c.isVoiceBased()).size;
|
|
const modules = settingsStore.get(guildId) || {};
|
|
res.json({
|
|
guild: {
|
|
id: guild.id,
|
|
name: guild.name,
|
|
icon: guild.icon,
|
|
memberCount: guild.memberCount,
|
|
createdAt: guild.createdAt?.getTime?.() || null,
|
|
owner: owner ? { id: owner.id, tag: owner.user?.tag } : null,
|
|
textCount,
|
|
voiceCount,
|
|
modules: {
|
|
ticketsEnabled: modules.ticketsEnabled !== false,
|
|
automodEnabled: modules.automodEnabled !== false,
|
|
musicEnabled: modules.musicEnabled !== false,
|
|
welcomeEnabled: modules.welcomeConfig?.enabled !== false,
|
|
dynamicVoiceEnabled: modules.dynamicVoiceEnabled !== false,
|
|
statuspageEnabled: (modules as any).statuspageEnabled !== false,
|
|
birthdayEnabled: (modules as any).birthdayEnabled !== false,
|
|
reactionRolesEnabled: (modules as any).reactionRolesEnabled !== false,
|
|
serverStatsEnabled: (modules as any).serverStatsEnabled === true || (modules as any).serverStatsConfig?.enabled === true
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
router.get('/guild/activity', requireAuth, (req, res) => {
|
|
const guildId = typeof req.query.guildId === 'string' ? req.query.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const activity = context.admin.getGuildActivity(guildId);
|
|
res.json({ activity });
|
|
});
|
|
|
|
router.get('/guild/logs', requireAuth, (req, res) => {
|
|
const guildId = typeof req.query.guildId === 'string' ? req.query.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const logs = context.admin.getGuildLogs(guildId).slice(0, 100);
|
|
res.json({ logs });
|
|
});
|
|
|
|
router.get('/overview', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.query.guildId === 'string' ? req.query.guildId : undefined;
|
|
try {
|
|
const [open, inProgress, closed] = await Promise.all([
|
|
prisma.ticket.count({ where: { status: 'open', ...(guildId ? { guildId } : {}) } }),
|
|
prisma.ticket.count({ where: { status: 'in-progress', ...(guildId ? { guildId } : {}) } }),
|
|
prisma.ticket.count({ where: { status: 'closed', ...(guildId ? { guildId } : {}) } })
|
|
]);
|
|
// TODO: MODULE: Musik-Status mit Modul-Flag und pro Guild Sessions anreichern (aktiv/inaktiv, aktueller Track).
|
|
const music = context.music.getStatus();
|
|
res.json({ tickets: { open, inProgress, closed }, music });
|
|
} catch (err) {
|
|
res.json({ tickets: { open: 0, inProgress: 0, closed: 0 }, error: 'DB unavailable' });
|
|
}
|
|
});
|
|
|
|
router.get('/admin/overview', requireAuth, requireAdmin, (_req, res) => {
|
|
const overview = context.admin.getOverview();
|
|
res.json({ overview });
|
|
});
|
|
|
|
router.get('/admin/activity', requireAuth, requireAdmin, (_req, res) => {
|
|
const activity = context.admin.getActivity();
|
|
res.json(activity);
|
|
});
|
|
|
|
router.get('/admin/logs', requireAuth, requireAdmin, (_req, res) => {
|
|
res.json({ logs: context.admin.getLogs() });
|
|
});
|
|
|
|
router.get('/tickets', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.query.guildId === 'string' ? req.query.guildId : undefined;
|
|
const status = typeof req.query.status === 'string' ? req.query.status : undefined;
|
|
const take = Math.min(Number(req.query.take ?? 20) || 20, 100);
|
|
const where: Record<string, any> = {};
|
|
if (guildId) where.guildId = guildId;
|
|
if (status) where.status = status;
|
|
try {
|
|
// TODO: TICKETS: Filter/Suche/Sortierung per Query-Params erweitern (Status, Claim, Priorität, Zeitfenster) für Dashboard.
|
|
const tickets = await prisma.ticket.findMany({ where, orderBy: { createdAt: 'desc' }, take });
|
|
res.json({ tickets });
|
|
} catch (err) {
|
|
res.json({ tickets: [], error: 'DB unavailable' });
|
|
}
|
|
});
|
|
|
|
router.get('/tickets/pipeline', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.query.guildId === 'string' ? req.query.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const tickets = await prisma.ticket.findMany({ where: { guildId }, orderBy: { createdAt: 'desc' }, take: 200 });
|
|
const grouped = { neu: [], in_bearbeitung: [], warten_auf_user: [], erledigt: [] } as Record<string, any[]>;
|
|
tickets.forEach((t) => {
|
|
const statusVal = ['neu', 'in_bearbeitung', 'warten_auf_user', 'erledigt'].includes(t.status) ? t.status : 'neu';
|
|
(grouped as any)[statusVal].push(t);
|
|
});
|
|
res.json({ pipeline: grouped });
|
|
});
|
|
|
|
router.post('/tickets/:id/status', requireAuth, async (req, res) => {
|
|
const ticketId = req.params.id;
|
|
const statusVal = typeof req.body.status === 'string' ? req.body.status : '';
|
|
if (!statusVal) return res.status(400).json({ error: 'status required' });
|
|
const updated = await context.tickets.updateStatus(ticketId, statusVal as any);
|
|
if (!updated) return res.status(404).json({ error: 'not found' });
|
|
res.json({ ticket: updated });
|
|
});
|
|
|
|
router.get('/tickets/sla', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.query.guildId === 'string' ? req.query.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const days = Math.min(Math.max(Number(req.query.days) || 30, 1), 180);
|
|
const since = new Date(Date.now() - days * 24 * 3600 * 1000);
|
|
const tickets = await prisma.ticket.findMany({
|
|
where: { guildId, createdAt: { gte: since } },
|
|
select: { createdAt: true, firstClaimAt: true, firstResponseAt: true, claimedBy: true }
|
|
});
|
|
const supporterStats: Record<
|
|
string,
|
|
{ supporterId: string; count: number; ttcSum: number; ttfrSum: number; ttfrCount: number; ttcCount: number }
|
|
> = {};
|
|
const dayStats: Record<
|
|
string,
|
|
{ date: string; count: number; ttcSum: number; ttfrSum: number; ttcCount: number; ttfrCount: number }
|
|
> = {};
|
|
tickets.forEach((t) => {
|
|
const dayKey = t.createdAt.toISOString().slice(0, 10);
|
|
if (!dayStats[dayKey]) dayStats[dayKey] = { date: dayKey, count: 0, ttcSum: 0, ttfrSum: 0, ttcCount: 0, ttfrCount: 0 };
|
|
dayStats[dayKey].count += 1;
|
|
if (t.claimedBy && t.firstClaimAt) {
|
|
const diff = t.firstClaimAt.getTime() - t.createdAt.getTime();
|
|
const key = t.claimedBy;
|
|
if (!supporterStats[key])
|
|
supporterStats[key] = { supporterId: key, count: 0, ttcSum: 0, ttfrSum: 0, ttcCount: 0, ttfrCount: 0 };
|
|
supporterStats[key].count += 1;
|
|
supporterStats[key].ttcSum += diff;
|
|
supporterStats[key].ttcCount += 1;
|
|
dayStats[dayKey].ttcSum += diff;
|
|
dayStats[dayKey].ttcCount += 1;
|
|
}
|
|
if (t.firstResponseAt) {
|
|
const diff = t.firstResponseAt.getTime() - t.createdAt.getTime();
|
|
if (t.claimedBy) {
|
|
const key = t.claimedBy;
|
|
if (!supporterStats[key])
|
|
supporterStats[key] = { supporterId: key, count: 0, ttcSum: 0, ttfrSum: 0, ttcCount: 0, ttfrCount: 0 };
|
|
supporterStats[key].ttfrSum += diff;
|
|
supporterStats[key].ttfrCount += 1;
|
|
}
|
|
dayStats[dayKey].ttfrSum += diff;
|
|
dayStats[dayKey].ttfrCount += 1;
|
|
}
|
|
});
|
|
const supporters = Object.values(supporterStats).map((s) => ({
|
|
supporterId: s.supporterId,
|
|
tickets: s.count,
|
|
avgTTC: s.ttcCount ? Math.round(s.ttcSum / s.ttcCount) : null,
|
|
avgTTFR: s.ttfrCount ? Math.round(s.ttfrSum / s.ttfrCount) : null
|
|
}));
|
|
const daysArr = Object.values(dayStats)
|
|
.sort((a, b) => a.date.localeCompare(b.date))
|
|
.map((d) => ({
|
|
date: d.date,
|
|
tickets: d.count,
|
|
avgTTC: d.ttcCount ? Math.round(d.ttcSum / d.ttcCount) : null,
|
|
avgTTFR: d.ttfrCount ? Math.round(d.ttfrSum / d.ttfrCount) : null
|
|
}));
|
|
res.json({ supporters, days: daysArr });
|
|
});
|
|
|
|
router.get('/tickets/:id/transcript', requireAuth, async (req, res) => {
|
|
const id = req.params.id;
|
|
try {
|
|
const ticket = await prisma.ticket.findFirst({ where: { id } });
|
|
if (!ticket || !ticket.transcript) return res.status(404).send('Transcript not found');
|
|
return res.sendFile(ticket.transcript);
|
|
} catch {
|
|
return res.status(500).send('Transcript error');
|
|
}
|
|
});
|
|
|
|
router.get('/tickets/:id/messages', requireAuth, async (req, res) => {
|
|
const id = req.params.id;
|
|
try {
|
|
const ticket = await prisma.ticket.findFirst({ where: { id } });
|
|
if (!ticket) return res.status(404).json({ error: 'not found' });
|
|
const channel = ticket.channelId ? await context.client?.channels.fetch(ticket.channelId) : null;
|
|
if (!channel || !channel.isTextBased()) return res.status(404).json({ error: 'channel missing' });
|
|
// TODO: TICKETS: Live-Messages per WebSocket/Server-Sent-Events streamen statt polling, inkl. Author-Rich-Info.
|
|
const msgs = await (channel as any).messages.fetch({ limit: 50 });
|
|
const data = msgs
|
|
.sort((a, b) => a.createdTimestamp - b.createdTimestamp)
|
|
.map((m: any) => ({
|
|
id: m.id,
|
|
author: { tag: m.author?.tag ?? 'Unknown', avatar: m.author?.displayAvatarURL?.() ?? null },
|
|
content: m.content,
|
|
createdAt: m.createdTimestamp
|
|
}));
|
|
res.json({ messages: data });
|
|
} catch {
|
|
res.status(500).json({ error: 'message fetch failed' });
|
|
}
|
|
});
|
|
|
|
router.post('/tickets/:id/close', requireAuth, async (req, res) => {
|
|
const id = req.params.id;
|
|
try {
|
|
const ticket = await prisma.ticket.findFirst({ where: { id } });
|
|
if (!ticket) return res.status(404).json({ error: 'not found' });
|
|
if (!context.client) return res.status(500).json({ error: 'client unavailable' });
|
|
const channel = await context.client.channels.fetch(ticket.channelId).catch(() => null);
|
|
if (channel && channel.isTextBased()) {
|
|
const transcriptPath = await context.tickets.exportTranscript(channel as any, ticket.id);
|
|
await prisma.ticket.update({ where: { id: ticket.id }, data: { status: 'closed', transcript: transcriptPath } });
|
|
await context.tickets['sendTranscriptToLog'](channel.guild, transcriptPath, ticket as any).catch(() => undefined);
|
|
await (channel as any).delete('Ticket geschlossen');
|
|
} else {
|
|
await prisma.ticket.update({ where: { id: ticket.id }, data: { status: 'closed' } });
|
|
}
|
|
res.json({ ok: true });
|
|
} catch {
|
|
res.status(500).json({ error: 'close failed' });
|
|
}
|
|
});
|
|
|
|
router.post('/tickets/panel', requireAuth, async (req, res) => {
|
|
const { guildId, channelId, title, description, categories } = req.body as {
|
|
guildId?: string;
|
|
channelId?: string;
|
|
title?: string;
|
|
description?: string;
|
|
categories?: { label: string; emoji?: string; customId: string }[];
|
|
};
|
|
if (!guildId || !channelId) return res.status(400).json({ error: 'guildId and channelId required' });
|
|
try {
|
|
// TODO: TICKETS: Panel-Template als Dashboard-Entwurf speichern (DB) statt ad-hoc zu senden; Mehrsprachigkeit berücksichtigen.
|
|
const cfg = settingsStore.get(guildId);
|
|
if (cfg?.ticketsEnabled === false) return res.status(403).json({ error: 'tickets disabled' });
|
|
if (!context.client) return res.status(503).json({ error: 'bot client unavailable' });
|
|
const guild = await context.client.guilds.fetch(guildId);
|
|
const channel = await guild.channels.fetch(channelId);
|
|
if (!channel || !channel.isTextBased()) return res.status(400).json({ error: 'channel not text' });
|
|
const cats = (categories ?? []).filter((c) => c?.label && c?.customId).slice(0, 5);
|
|
const panel =
|
|
cats.length > 0
|
|
? context.tickets.buildCustomPanel({ title, description, categories: cats })
|
|
: context.tickets.buildPanelEmbed();
|
|
const { embed, buttons } = panel;
|
|
await (channel as any).send({ embeds: [embed], components: [buttons] });
|
|
return res.json({ ok: true });
|
|
} catch (err: any) {
|
|
const code = err?.code || err?.status || err?.name;
|
|
const message = err?.message || 'failed to send panel';
|
|
if (code === 50001 || code === 'Missing Access') return res.status(403).json({ error: 'missing access' });
|
|
if (code === 50013 || /Missing Permissions/i.test(message)) return res.status(403).json({ error: 'missing permissions', detail: message });
|
|
if (code === 10003 || code === 'Unknown Channel') return res.status(404).json({ error: 'channel not found' });
|
|
console.error('tickets/panel error', code, message);
|
|
return res.status(500).json({ error: 'failed to send panel', detail: message });
|
|
}
|
|
});
|
|
|
|
router.get('/tickets/support-login', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.query.guildId === 'string' ? req.query.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const cfg = settingsStore.get(guildId) || {};
|
|
const config = {
|
|
panelChannelId: cfg.supportLoginConfig?.panelChannelId || '',
|
|
panelMessageId: cfg.supportLoginConfig?.panelMessageId || '',
|
|
title: cfg.supportLoginConfig?.title || 'Support Login',
|
|
description: cfg.supportLoginConfig?.description || 'Melde dich als Support an/ab.',
|
|
loginLabel: cfg.supportLoginConfig?.loginLabel || 'Ich bin jetzt im Support',
|
|
logoutLabel: cfg.supportLoginConfig?.logoutLabel || 'Ich bin nicht mehr im Support',
|
|
autoRefresh: cfg.supportLoginConfig?.autoRefresh !== false
|
|
};
|
|
const status = await context.tickets.getSupportStatus(guildId);
|
|
res.json({ config, status, supportRoleId: cfg.supportRoleId || null });
|
|
});
|
|
|
|
router.post('/tickets/support-login', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.body.guildId === 'string' ? req.body.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const config = {
|
|
panelChannelId: typeof req.body.panelChannelId === 'string' ? req.body.panelChannelId : undefined,
|
|
title: typeof req.body.title === 'string' ? req.body.title : undefined,
|
|
description: typeof req.body.description === 'string' ? req.body.description : undefined,
|
|
loginLabel: typeof req.body.loginLabel === 'string' ? req.body.loginLabel : undefined,
|
|
logoutLabel: typeof req.body.logoutLabel === 'string' ? req.body.logoutLabel : undefined,
|
|
autoRefresh: req.body.autoRefresh !== undefined ? !!req.body.autoRefresh : undefined
|
|
};
|
|
await settingsStore.set(guildId, { supportLoginConfig: config } as any);
|
|
const msgId = await context.tickets.publishSupportPanel(guildId, config).catch(() => null);
|
|
if (msgId) await settingsStore.set(guildId, { supportLoginConfig: { ...config, panelMessageId: msgId } } as any);
|
|
res.json({ ok: true, config: { ...config, panelMessageId: msgId || config['panelMessageId'] } });
|
|
});
|
|
|
|
router.get('/events', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.query.guildId === 'string' ? req.query.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const events = await prisma.event.findMany({
|
|
where: { guildId },
|
|
orderBy: { startTime: 'asc' },
|
|
include: { _count: { select: { signups: { where: { canceledAt: null } } as any } as any } as any } as any
|
|
} as any);
|
|
res.json({ events });
|
|
});
|
|
|
|
router.post('/events', requireAuth, async (req, res) => {
|
|
const {
|
|
id,
|
|
guildId,
|
|
title,
|
|
description,
|
|
channelId,
|
|
startTime,
|
|
repeatType,
|
|
repeatConfig,
|
|
reminderOffsetMinutes,
|
|
roleId,
|
|
isActive
|
|
} = req.body || {};
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
try {
|
|
const saved = await context.events.saveEvent({
|
|
id,
|
|
guildId,
|
|
title,
|
|
description,
|
|
channelId,
|
|
startTime,
|
|
repeatType,
|
|
repeatConfig,
|
|
reminderOffsetMinutes,
|
|
roleId,
|
|
isActive
|
|
});
|
|
res.json({ ok: true, event: saved });
|
|
} catch {
|
|
res.status(500).json({ error: 'save failed' });
|
|
}
|
|
});
|
|
|
|
router.delete('/events/:id', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.body.guildId === 'string' ? req.body.guildId : undefined;
|
|
const id = req.params.id;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
await context.events.deleteEvent(guildId, id);
|
|
res.json({ ok: true });
|
|
});
|
|
|
|
router.get('/settings', requireAuth, (req, res) => {
|
|
const guildId = typeof req.query.guildId === 'string' ? req.query.guildId : undefined;
|
|
if (guildId) {
|
|
return res.json({ guildId, settings: settingsStore.get(guildId) ?? {} });
|
|
}
|
|
res.json({ guilds: Array.from(settingsStore.all().entries()) });
|
|
});
|
|
|
|
router.get('/modules', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.query.guildId === 'string' ? req.query.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const modules = await moduleService.getModulesForGuild(guildId);
|
|
res.json({ modules });
|
|
});
|
|
|
|
router.get('/birthday', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.query.guildId === 'string' ? req.query.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const cfg = settingsStore.get(guildId) || {};
|
|
const config = {
|
|
enabled: cfg.birthdayEnabled ?? cfg.birthdayConfig?.enabled ?? true,
|
|
channelId: cfg.birthdayConfig?.channelId ?? '',
|
|
sendHour: cfg.birthdayConfig?.sendHour ?? 9,
|
|
messageTemplate: cfg.birthdayConfig?.messageTemplate ?? 'Alles Gute zum Geburtstag, {user}!'
|
|
};
|
|
const birthdays = await prisma.birthday.findMany({ where: { guildId }, orderBy: { birthDate: 'asc' }, take: 200 });
|
|
res.json({ config, birthdays });
|
|
});
|
|
|
|
router.post('/birthday', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.body.guildId === 'string' ? req.body.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const enabledRaw = req.body.enabled;
|
|
const channelId = typeof req.body.channelId === 'string' ? req.body.channelId.trim() : undefined;
|
|
const template = typeof req.body.messageTemplate === 'string' ? req.body.messageTemplate.slice(0, 500) : undefined;
|
|
const hour = Number(req.body.sendHour);
|
|
const sendHour = Number.isFinite(hour) ? Math.min(23, Math.max(0, Math.round(hour))) : undefined;
|
|
const enabled = typeof enabledRaw === 'string' ? enabledRaw === 'true' : enabledRaw;
|
|
const config = {
|
|
enabled,
|
|
channelId: channelId || undefined,
|
|
sendHour,
|
|
messageTemplate: template
|
|
};
|
|
await settingsStore.set(guildId, { birthdayEnabled: enabled, birthdayConfig: config } as any);
|
|
context.birthdays.invalidate(guildId);
|
|
res.json({ ok: true, config });
|
|
});
|
|
|
|
router.get('/reactionroles', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.query.guildId === 'string' ? req.query.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const sets = await context.reactionRoles.listSets(guildId);
|
|
res.json({ sets });
|
|
});
|
|
|
|
router.post('/reactionroles', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.body.guildId === 'string' ? req.body.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
if (!req.body.channelId) return res.status(400).json({ error: 'channelId required' });
|
|
const entries = Array.isArray(req.body.entries)
|
|
? req.body.entries
|
|
.map((e: any) => ({
|
|
emoji: typeof e.emoji === 'string' ? e.emoji.trim() : '',
|
|
roleId: typeof e.roleId === 'string' ? e.roleId.trim() : '',
|
|
label: typeof e.label === 'string' ? e.label.trim() : undefined,
|
|
description: typeof e.description === 'string' ? e.description.trim() : undefined
|
|
}))
|
|
.filter((e: any) => e.emoji && e.roleId)
|
|
: [];
|
|
if (!entries.length) return res.status(400).json({ error: 'entries required' });
|
|
try {
|
|
const set = await context.reactionRoles.saveSet({
|
|
guildId,
|
|
channelId: typeof req.body.channelId === 'string' ? req.body.channelId : '',
|
|
messageId: typeof req.body.messageId === 'string' ? req.body.messageId : undefined,
|
|
title: typeof req.body.title === 'string' ? req.body.title : undefined,
|
|
description: typeof req.body.description === 'string' ? req.body.description : undefined,
|
|
entries
|
|
});
|
|
res.json({ set });
|
|
} catch (err) {
|
|
res.status(400).json({ error: 'save failed' });
|
|
}
|
|
});
|
|
|
|
router.put('/reactionroles/:id', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.body.guildId === 'string' ? req.body.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const id = req.params.id;
|
|
if (!req.body.channelId) return res.status(400).json({ error: 'channelId required' });
|
|
const entries = Array.isArray(req.body.entries)
|
|
? req.body.entries
|
|
.map((e: any) => ({
|
|
emoji: typeof e.emoji === 'string' ? e.emoji.trim() : '',
|
|
roleId: typeof e.roleId === 'string' ? e.roleId.trim() : '',
|
|
label: typeof e.label === 'string' ? e.label.trim() : undefined,
|
|
description: typeof e.description === 'string' ? e.description.trim() : undefined
|
|
}))
|
|
.filter((e: any) => e.emoji && e.roleId)
|
|
: [];
|
|
if (!entries.length) return res.status(400).json({ error: 'entries required' });
|
|
try {
|
|
const set = await context.reactionRoles.saveSet({
|
|
id,
|
|
guildId,
|
|
channelId: typeof req.body.channelId === 'string' ? req.body.channelId : '',
|
|
messageId: typeof req.body.messageId === 'string' ? req.body.messageId : undefined,
|
|
title: typeof req.body.title === 'string' ? req.body.title : undefined,
|
|
description: typeof req.body.description === 'string' ? req.body.description : undefined,
|
|
entries
|
|
});
|
|
res.json({ set });
|
|
} catch (err) {
|
|
res.status(400).json({ error: 'save failed' });
|
|
}
|
|
});
|
|
|
|
router.delete('/reactionroles/:id', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.body.guildId === 'string' ? req.body.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const id = req.params.id;
|
|
try {
|
|
await context.reactionRoles.deleteSet(guildId, id);
|
|
res.json({ ok: true });
|
|
} catch {
|
|
res.status(400).json({ error: 'delete failed' });
|
|
}
|
|
});
|
|
|
|
router.get('/register/forms', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.query.guildId === 'string' ? req.query.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const forms = await context.register.listForms(guildId);
|
|
res.json({ forms });
|
|
});
|
|
|
|
router.post('/register/forms', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.body.guildId === 'string' ? req.body.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const data = req.body || {};
|
|
const form = await context.register.saveForm({
|
|
guildId,
|
|
name: data.name || 'Formular',
|
|
description: data.description || '',
|
|
reviewChannelId: data.reviewChannelId || undefined,
|
|
notifyRoleIds: Array.isArray(data.notifyRoleIds) ? data.notifyRoleIds : typeof data.notifyRoleIds === 'string' ? data.notifyRoleIds.split(',').map((s: string) => s.trim()).filter(Boolean) : [],
|
|
isActive: data.isActive !== false,
|
|
fields: Array.isArray(data.fields) ? data.fields : []
|
|
});
|
|
res.json({ form });
|
|
});
|
|
|
|
router.put('/register/forms/:id', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.body.guildId === 'string' ? req.body.guildId : undefined;
|
|
const id = req.params.id;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const data = req.body || {};
|
|
const form = await context.register.saveForm({
|
|
id,
|
|
guildId,
|
|
name: data.name || 'Formular',
|
|
description: data.description || '',
|
|
reviewChannelId: data.reviewChannelId || undefined,
|
|
notifyRoleIds: Array.isArray(data.notifyRoleIds) ? data.notifyRoleIds : typeof data.notifyRoleIds === 'string' ? data.notifyRoleIds.split(',').map((s: string) => s.trim()).filter(Boolean) : [],
|
|
isActive: data.isActive !== false,
|
|
fields: Array.isArray(data.fields) ? data.fields : []
|
|
});
|
|
res.json({ form });
|
|
});
|
|
|
|
router.delete('/register/forms/:id', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.body.guildId === 'string' ? req.body.guildId : undefined;
|
|
const id = req.params.id;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const ok = await context.register.deleteForm(guildId, id);
|
|
if (!ok) return res.status(404).json({ error: 'not found' });
|
|
res.json({ ok: true });
|
|
});
|
|
|
|
router.post('/register/forms/:id/panel', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.body.guildId === 'string' ? req.body.guildId : undefined;
|
|
const id = req.params.id;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const channelId = typeof req.body.channelId === 'string' ? req.body.channelId : undefined;
|
|
const message = typeof req.body.message === 'string' ? req.body.message : undefined;
|
|
const msgId = await context.register.sendPanel(guildId, id, channelId, message);
|
|
if (!msgId) return res.status(400).json({ error: 'panel failed' });
|
|
res.json({ ok: true, messageId: msgId });
|
|
});
|
|
|
|
router.get('/register/apps', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.query.guildId === 'string' ? req.query.guildId : undefined;
|
|
const status = typeof req.query.status === 'string' ? req.query.status : undefined;
|
|
const formId = typeof req.query.formId === 'string' ? req.query.formId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const apps = await context.register.listApplications(guildId, status, formId);
|
|
res.json({ applications: apps });
|
|
});
|
|
|
|
router.get('/register/apps/:id', requireAuth, async (req, res) => {
|
|
const app = await context.register.getApplication(req.params.id);
|
|
if (!app) return res.status(404).json({ error: 'not found' });
|
|
res.json({ application: app });
|
|
});
|
|
|
|
router.get('/automations', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.query.guildId === 'string' ? req.query.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const rules = await context.ticketAutomation.list(guildId);
|
|
res.json({ rules });
|
|
});
|
|
|
|
router.post('/automations', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.body.guildId === 'string' ? req.body.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const rule = await context.ticketAutomation.save({
|
|
guildId,
|
|
name: req.body.name || 'Automation',
|
|
condition: req.body.condition || {},
|
|
action: req.body.action || {},
|
|
active: req.body.active !== false
|
|
});
|
|
res.json({ rule });
|
|
});
|
|
|
|
router.put('/automations/:id', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.body.guildId === 'string' ? req.body.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const id = req.params.id;
|
|
const rule = await context.ticketAutomation.save({
|
|
id,
|
|
guildId,
|
|
name: req.body.name || 'Automation',
|
|
condition: req.body.condition || {},
|
|
action: req.body.action || {},
|
|
active: req.body.active !== false
|
|
});
|
|
res.json({ rule });
|
|
});
|
|
|
|
router.delete('/automations/:id', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.body.guildId === 'string' ? req.body.guildId : undefined;
|
|
const id = req.params.id;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const ok = await context.ticketAutomation.remove(guildId, id);
|
|
if (!ok) return res.status(404).json({ error: 'not found' });
|
|
res.json({ ok: true });
|
|
});
|
|
|
|
router.get('/kb', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.query.guildId === 'string' ? req.query.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const articles = await context.knowledgeBase.list(guildId);
|
|
res.json({ articles });
|
|
});
|
|
|
|
router.post('/kb', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.body.guildId === 'string' ? req.body.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const keywords =
|
|
typeof req.body.keywords === 'string'
|
|
? req.body.keywords
|
|
.split(',')
|
|
.map((s: string) => s.trim())
|
|
.filter(Boolean)
|
|
: req.body.keywords || [];
|
|
const article = await context.knowledgeBase.save({
|
|
guildId,
|
|
title: req.body.title || 'Artikel',
|
|
keywords,
|
|
content: req.body.content || ''
|
|
});
|
|
res.json({ article });
|
|
});
|
|
|
|
router.put('/kb/:id', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.body.guildId === 'string' ? req.body.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const id = req.params.id;
|
|
const keywords =
|
|
typeof req.body.keywords === 'string'
|
|
? req.body.keywords
|
|
.split(',')
|
|
.map((s: string) => s.trim())
|
|
.filter(Boolean)
|
|
: req.body.keywords || [];
|
|
const article = await context.knowledgeBase.save({
|
|
id,
|
|
guildId,
|
|
title: req.body.title || 'Artikel',
|
|
keywords,
|
|
content: req.body.content || ''
|
|
});
|
|
res.json({ article });
|
|
});
|
|
|
|
router.delete('/kb/:id', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.body.guildId === 'string' ? req.body.guildId : undefined;
|
|
const id = req.params.id;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const ok = await context.knowledgeBase.remove(guildId, id);
|
|
if (!ok) return res.status(404).json({ error: 'not found' });
|
|
res.json({ ok: true });
|
|
});
|
|
|
|
router.get('/statuspage', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.query.guildId === 'string' ? req.query.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const cfg = await context.statuspage.getConfig(guildId);
|
|
res.json({ config: cfg });
|
|
});
|
|
|
|
router.post('/statuspage', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.body.guildId === 'string' ? req.body.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
await context.statuspage.saveConfig(guildId, req.body.config || {});
|
|
res.json({ ok: true });
|
|
});
|
|
|
|
router.post('/statuspage/service', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.body.guildId === 'string' ? req.body.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const svc = await context.statuspage.addService(guildId, req.body.service || {});
|
|
res.json({ service: svc });
|
|
});
|
|
|
|
router.put('/statuspage/service/:id', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.body.guildId === 'string' ? req.body.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
await context.statuspage.updateService(guildId, req.params.id, req.body.service || {});
|
|
res.json({ ok: true });
|
|
});
|
|
|
|
router.delete('/statuspage/service/:id', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.body.guildId === 'string' ? req.body.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
await context.statuspage.deleteService(guildId, req.params.id);
|
|
res.json({ ok: true });
|
|
});
|
|
|
|
router.get('/server-stats', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.query.guildId === 'string' ? req.query.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const cfg = await context.stats.getConfig(guildId);
|
|
res.json({ config: cfg });
|
|
});
|
|
|
|
router.post('/server-stats', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.body.guildId === 'string' ? req.body.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const cfg = await context.stats.saveConfig(guildId, req.body.config || {});
|
|
res.json({ config: cfg });
|
|
});
|
|
|
|
router.post('/server-stats/refresh', requireAuth, async (req, res) => {
|
|
const guildId = typeof req.body.guildId === 'string' ? req.body.guildId : undefined;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
await context.stats.refreshGuild(guildId);
|
|
res.json({ ok: true });
|
|
});
|
|
|
|
router.post('/settings', requireAuth, async (req, res) => {
|
|
const current = req.body.guildId ? settingsStore.get(req.body.guildId) ?? {} : {};
|
|
const {
|
|
guildId,
|
|
welcomeChannelId,
|
|
logChannelId,
|
|
automodEnabled,
|
|
automodConfig,
|
|
loggingConfig,
|
|
welcomeConfig,
|
|
welcomeEnabled,
|
|
levelingEnabled,
|
|
ticketsEnabled,
|
|
musicEnabled,
|
|
dynamicVoiceEnabled,
|
|
dynamicVoiceConfig,
|
|
supportRoleId,
|
|
statuspageEnabled,
|
|
statuspageConfig,
|
|
eventsEnabled,
|
|
birthdayEnabled,
|
|
birthdayConfig,
|
|
reactionRolesEnabled,
|
|
reactionRolesConfig,
|
|
registerEnabled,
|
|
registerConfig,
|
|
serverStatsEnabled,
|
|
serverStatsConfig
|
|
} = req.body;
|
|
if (!guildId) return res.status(400).json({ error: 'guildId required' });
|
|
const normalizeArray = (val: any) =>
|
|
Array.isArray(val)
|
|
? val.map((s) => String(s).trim()).filter(Boolean)
|
|
: typeof val === 'string'
|
|
? val
|
|
.split(/[,\\n]/)
|
|
.map((s: string) => s.trim())
|
|
.filter(Boolean)
|
|
: [];
|
|
|
|
const existingLogging = (current as any).loggingConfig || (current as any).automodConfig?.loggingConfig || {};
|
|
const parsedLogging = {
|
|
logChannelId: loggingConfig?.logChannelId ?? logChannelId ?? existingLogging.logChannelId ?? undefined,
|
|
categories: {
|
|
joinLeave: loggingConfig?.categories?.joinLeave ?? loggingConfig?.joinLeave ?? existingLogging.categories?.joinLeave ?? true,
|
|
messageEdit: loggingConfig?.categories?.messageEdit ?? loggingConfig?.messageEdit ?? existingLogging.categories?.messageEdit ?? true,
|
|
messageDelete: loggingConfig?.categories?.messageDelete ?? loggingConfig?.messageDelete ?? existingLogging.categories?.messageDelete ?? true,
|
|
automodActions: loggingConfig?.categories?.automodActions ?? loggingConfig?.automodActions ?? existingLogging.categories?.automodActions ?? true,
|
|
ticketActions: loggingConfig?.categories?.ticketActions ?? loggingConfig?.ticketActions ?? existingLogging.categories?.ticketActions ?? true,
|
|
musicEvents: loggingConfig?.categories?.musicEvents ?? loggingConfig?.musicEvents ?? existingLogging.categories?.musicEvents ?? true,
|
|
system: loggingConfig?.categories?.system ?? existingLogging.categories?.system ?? true
|
|
}
|
|
};
|
|
|
|
let parsedAutomod =
|
|
typeof automodConfig === 'object'
|
|
? { ...(current as any).automodConfig, ...(automodConfig ?? {}) }
|
|
: automodConfig === undefined
|
|
? { ...(current as any).automodConfig }
|
|
: {
|
|
...(current as any).automodConfig,
|
|
spamThreshold: automodConfig?.spamThreshold ? Number(automodConfig.spamThreshold) : undefined,
|
|
windowMs: automodConfig?.windowMs ? Number(automodConfig.windowMs) : undefined,
|
|
linkWhitelist:
|
|
typeof automodConfig?.linkWhitelist === 'string'
|
|
? automodConfig.linkWhitelist
|
|
.split(',')
|
|
.map((s: string) => s.trim())
|
|
.filter(Boolean)
|
|
: undefined,
|
|
spamTimeoutMinutes: automodConfig?.spamTimeoutMinutes ? Number(automodConfig.spamTimeoutMinutes) : undefined,
|
|
deleteLinks: automodConfig?.deleteLinks !== undefined ? automodConfig.deleteLinks === 'true' || automodConfig.deleteLinks === true : undefined
|
|
};
|
|
parsedAutomod.customBadwords = normalizeArray(automodConfig?.customBadwords);
|
|
parsedAutomod.whitelistRoles = normalizeArray(automodConfig?.whitelistRoles);
|
|
parsedAutomod.logChannelId = automodConfig?.logChannelId ?? logChannelId ?? parsedLogging.logChannelId;
|
|
parsedAutomod.loggingConfig = parsedLogging;
|
|
parsedAutomod.statuspageEnabled =
|
|
typeof statuspageEnabled === 'string' ? statuspageEnabled === 'true' : statuspageEnabled ?? (current as any).statuspageEnabled;
|
|
parsedAutomod.statuspageConfig = statuspageConfig ?? (current as any).statuspageConfig;
|
|
const normalizedWelcomeEnabled = typeof welcomeEnabled === 'string' ? welcomeEnabled === 'true' : welcomeEnabled;
|
|
const parsedWelcome = {
|
|
enabled: welcomeConfig?.enabled ?? normalizedWelcomeEnabled ?? (current as any).welcomeConfig?.enabled ?? false,
|
|
channelId: welcomeConfig?.channelId ?? (current as any).welcomeConfig?.channelId ?? (current as any).welcomeChannelId ?? undefined,
|
|
embedTitle: welcomeConfig?.embedTitle ?? (current as any).welcomeConfig?.embedTitle,
|
|
embedDescription: welcomeConfig?.embedDescription ?? (current as any).welcomeConfig?.embedDescription,
|
|
embedColor: welcomeConfig?.embedColor ?? (current as any).welcomeConfig?.embedColor,
|
|
embedFooter: welcomeConfig?.embedFooter ?? (current as any).welcomeConfig?.embedFooter,
|
|
embedThumbnail: welcomeConfig?.embedThumbnail ?? (current as any).welcomeConfig?.embedThumbnail,
|
|
embedImage: welcomeConfig?.embedImage ?? (current as any).welcomeConfig?.embedImage,
|
|
embedThumbnailData: welcomeConfig?.embedThumbnailData ?? (current as any).welcomeConfig?.embedThumbnailData,
|
|
embedImageData: welcomeConfig?.embedImageData ?? (current as any).welcomeConfig?.embedImageData
|
|
};
|
|
parsedAutomod.welcomeConfig = parsedWelcome;
|
|
|
|
const parsedDynamicVoice = {
|
|
lobbyChannelId: dynamicVoiceConfig?.lobbyChannelId ?? (current as any).dynamicVoiceConfig?.lobbyChannelId,
|
|
categoryId: dynamicVoiceConfig?.categoryId ?? (current as any).dynamicVoiceConfig?.categoryId,
|
|
template: dynamicVoiceConfig?.template ?? (current as any).dynamicVoiceConfig?.template,
|
|
userLimit: dynamicVoiceConfig?.userLimit ?? (current as any).dynamicVoiceConfig?.userLimit,
|
|
bitrate: dynamicVoiceConfig?.bitrate ?? (current as any).dynamicVoiceConfig?.bitrate
|
|
};
|
|
|
|
const existingBirthday = (current as any).birthdayConfig || {};
|
|
const sendHourVal = birthdayConfig?.sendHour ?? existingBirthday.sendHour;
|
|
const parsedBirthday = {
|
|
enabled:
|
|
birthdayConfig?.enabled ??
|
|
(typeof birthdayEnabled === 'string' ? birthdayEnabled === 'true' : birthdayEnabled ?? (current as any).birthdayEnabled),
|
|
channelId: birthdayConfig?.channelId ?? existingBirthday.channelId,
|
|
sendHour: Number.isFinite(Number(sendHourVal)) ? Math.min(23, Math.max(0, Number(sendHourVal))) : existingBirthday.sendHour,
|
|
messageTemplate: birthdayConfig?.messageTemplate ?? existingBirthday.messageTemplate
|
|
};
|
|
|
|
const existingReactionRoles = (current as any).reactionRolesConfig || {};
|
|
const parsedReactionRoles = {
|
|
enabled:
|
|
reactionRolesConfig?.enabled ??
|
|
(typeof reactionRolesEnabled === 'string'
|
|
? reactionRolesEnabled === 'true'
|
|
: reactionRolesEnabled ?? (current as any).reactionRolesEnabled),
|
|
channelId: reactionRolesConfig?.channelId ?? existingReactionRoles.channelId
|
|
};
|
|
|
|
const parsedRegister = {
|
|
enabled:
|
|
registerConfig?.enabled ??
|
|
(typeof registerEnabled === 'string' ? registerEnabled === 'true' : registerEnabled ?? (current as any).registerEnabled),
|
|
reviewChannelId: registerConfig?.reviewChannelId ?? (current as any).registerConfig?.reviewChannelId,
|
|
notifyRoleIds:
|
|
Array.isArray(registerConfig?.notifyRoleIds) && registerConfig?.notifyRoleIds.length
|
|
? registerConfig.notifyRoleIds
|
|
: typeof registerConfig?.notifyRoleIds === 'string'
|
|
? registerConfig.notifyRoleIds
|
|
.split(',')
|
|
.map((s: string) => s.trim())
|
|
.filter(Boolean)
|
|
: (current as any).registerConfig?.notifyRoleIds || []
|
|
};
|
|
|
|
const updated = await settingsStore.set(guildId, {
|
|
welcomeChannelId: welcomeChannelId ?? undefined,
|
|
logChannelId: logChannelId ?? undefined,
|
|
automodEnabled: typeof automodEnabled === 'string' ? automodEnabled === 'true' : automodEnabled,
|
|
automodConfig: parsedAutomod,
|
|
welcomeConfig: parsedWelcome,
|
|
loggingConfig: parsedLogging,
|
|
levelingEnabled: typeof levelingEnabled === 'string' ? levelingEnabled === 'true' : levelingEnabled,
|
|
ticketsEnabled: typeof ticketsEnabled === 'string' ? ticketsEnabled === 'true' : ticketsEnabled,
|
|
musicEnabled: typeof musicEnabled === 'string' ? musicEnabled === 'true' : musicEnabled,
|
|
dynamicVoiceEnabled: typeof dynamicVoiceEnabled === 'string' ? dynamicVoiceEnabled === 'true' : dynamicVoiceEnabled,
|
|
dynamicVoiceConfig: parsedDynamicVoice,
|
|
supportRoleId: supportRoleId ?? undefined,
|
|
statuspageEnabled: typeof statuspageEnabled === 'string' ? statuspageEnabled === 'true' : statuspageEnabled,
|
|
statuspageConfig: parsedAutomod.statuspageConfig,
|
|
eventsEnabled: typeof eventsEnabled === 'string' ? eventsEnabled === 'true' : eventsEnabled,
|
|
birthdayEnabled: parsedBirthday.enabled,
|
|
birthdayConfig: parsedBirthday,
|
|
reactionRolesEnabled: parsedReactionRoles.enabled,
|
|
reactionRolesConfig: parsedReactionRoles,
|
|
registerEnabled: parsedRegister.enabled,
|
|
registerConfig: parsedRegister,
|
|
serverStatsEnabled: typeof serverStatsEnabled === 'string' ? serverStatsEnabled === 'true' : serverStatsEnabled,
|
|
serverStatsConfig: serverStatsConfig
|
|
});
|
|
// Live update logging target
|
|
context.logging = new LoggingService(updated.logChannelId);
|
|
const { setLoggingAdmin } = await import('../../services/loggingService');
|
|
setLoggingAdmin(context.admin);
|
|
res.json({ ok: true, settings: updated });
|
|
});
|
|
|
|
export default router;
|