Foundry and discord bot
All checks were successful
Build and Deploy Nuxt / build (push) Successful in 1m51s

This commit is contained in:
2026-10-11 22:26:29 +02:00
parent a2b512699a
commit 1402045001
65 changed files with 5962 additions and 144 deletions

View File

@@ -0,0 +1,272 @@
const crypto = require('node:crypto');
const express = require('express');
const passport = require('passport');
const router = express.Router();
const Actor = require('../models/Actor');
const Campaign = require('../models/Campaign');
const DiscordGuildLink = require('../models/DiscordGuildLink');
const DiscordLinkRequest = require('../models/DiscordLinkRequest');
const User = require('../models/User');
const LINK_TTL_MS = 10 * 60 * 1000;
const NOTIFICATION_WINDOW_MS = 15 * 60 * 1000;
const NOTIFICATION_LIMIT = 10;
function validGuildId(value) {
return /^\d{5,25}$/.test(String(value ?? ''));
}
function codeHash(code) {
return crypto.createHash('sha256').update(String(code ?? '')).digest('hex');
}
function requireBot(req, res, next) {
const configuredSecret = process.env.DRAGONROLL_DISCORD_BOT_SECRET?.trim() || '';
const suppliedSecret = req.get('x-dragonroll-discord-bot-secret') || '';
const expected = Buffer.from(configuredSecret);
const supplied = Buffer.from(suppliedSecret);
if (!expected.length || expected.length !== supplied.length || !crypto.timingSafeEqual(expected, supplied)) {
return res.status(401).json({ status: 'error', msg: 'errors.unauthorized' });
}
return next();
}
function frontendAuthorizeUrl() {
const frontendUrl = (process.env.DRAGONROLL_FRONTEND_URL || 'http://localhost:3000').trim().replace(/\/+$/, '');
return `${frontendUrl}/discord/authorize`;
}
// La pantalla d'autorització l'serveix el frontend. El codi viatja al fragment de la URL i el
// navegador no l'envia mai al servidor, així que els enllaços antics del bot arriben a la
// pantalla sense codi i demanen de tornar a executar /dragonroll connect.
router.get('/authorize', (req, res) => {
res.set('Cache-Control', 'no-store');
res.set('Referrer-Policy', 'no-referrer');
res.set('X-Content-Type-Options', 'nosniff');
res.redirect(302, frontendAuthorizeUrl());
});
router.post('/link/start', requireBot, async (req, res) => {
try {
const { guildId, guildName, discordUserId, discordUserName } = req.body;
if (!validGuildId(guildId) || !/^\d{5,25}$/.test(String(discordUserId ?? '')) || !guildName || !discordUserName) {
return res.json({ status: 'error', msg: 'errors.missing-data' });
}
const code = crypto.randomBytes(32).toString('base64url');
await DiscordLinkRequest.create({
codeHash: codeHash(code),
guildId: String(guildId),
guildName: String(guildName).slice(0, 100),
discordUserId: String(discordUserId),
discordUserName: String(discordUserName).slice(0, 100),
expiresAt: new Date(Date.now() + LINK_TTL_MS)
});
res.json({ status: 'ok', code, expiresAt: new Date(Date.now() + LINK_TTL_MS) });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
router.post('/link/details', async (req, res) => {
try {
res.set('Cache-Control', 'no-store');
const request = await DiscordLinkRequest.findOne({
codeHash: codeHash(req.body.code),
expiresAt: { $gt: new Date() },
completedAt: null
}).lean();
if (!request) return res.json({ status: 'error', msg: 'discord.errors.link-expired' });
res.json({ status: 'ok', guildName: request.guildName, discordUserName: request.discordUserName });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
router.post('/link/complete', passport.authenticate('jwt', { session: false }), async (req, res) => {
try {
const request = await DiscordLinkRequest.findOneAndUpdate({
codeHash: codeHash(req.body.code),
expiresAt: { $gt: new Date() },
completedAt: null
}, {
$set: { completedAt: new Date(), dragonrollUser: req.user.id }
}, { new: true });
if (!request) return res.json({ status: 'error', msg: 'discord.errors.link-expired' });
await Campaign.updateMany(
{ discordGuildId: request.guildId, createdBy: { $ne: req.user.id } },
{ $unset: { discordGuildId: 1 } }
);
await DiscordGuildLink.findOneAndUpdate({ guildId: request.guildId }, {
$set: {
discordUserId: request.discordUserId,
dragonrollUser: req.user.id,
connectedAt: new Date()
}
}, { new: true, upsert: true, setDefaultsOnInsert: true });
res.json({ status: 'ok', guildName: request.guildName });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
async function dragonrollUserNames(requests) {
const userIds = [...new Set(requests.map((request) => String(request.dragonrollUser ?? '')).filter(Boolean))];
if (!userIds.length) return new Map();
const users = await User.find({ _id: { $in: userIds } }).select('username name').lean();
return new Map(users.map((user) => [String(user._id), user.username || user.name]));
}
// El bot reclama les autoritzacions ja fetes per confirmar-les a Discord. Marcar-les aqui
// mateix evita que dos processos del bot confirmïn la mateixa vegada.
router.post('/bot/link-requests/notifications', requireBot, async (req, res) => {
try {
const pending = await DiscordLinkRequest.find({
completedAt: { $gte: new Date(Date.now() - NOTIFICATION_WINDOW_MS) },
notifiedAt: null
}).select('_id guildId guildName discordUserId discordUserName dragonrollUser')
.limit(NOTIFICATION_LIMIT)
.lean();
const claimed = [];
for (const request of pending) {
const taken = await DiscordLinkRequest.findOneAndUpdate(
{ _id: request._id, notifiedAt: null },
{ $set: { notifiedAt: new Date() } },
{ new: true }
).lean();
if (taken) claimed.push(request);
}
const names = await dragonrollUserNames(claimed);
res.json({
status: 'ok',
notifications: claimed.map((request) => ({
id: String(request._id),
guildId: request.guildId,
guildName: request.guildName,
discordUserId: request.discordUserId,
discordUserName: request.discordUserName,
dragonrollUserName: names.get(String(request.dragonrollUser ?? '')) || null
}))
});
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
router.get('/bot/guild/:guildId/status', requireBot, async (req, res) => {
try {
if (!validGuildId(req.params.guildId)) return res.json({ status: 'error', msg: 'errors.missing-data' });
const link = await DiscordGuildLink.findOne({ guildId: req.params.guildId }).lean();
if (!link) return res.json({ status: 'ok', connected: false, campaign: null });
const campaign = await Campaign.findOne({
discordGuildId: req.params.guildId,
createdBy: link.dragonrollUser
}).select('_id name').lean();
res.json({ status: 'ok', connected: true, campaign });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
router.get('/bot/guild/:guildId/campaigns', requireBot, async (req, res) => {
try {
if (!validGuildId(req.params.guildId)) return res.json({ status: 'error', msg: 'errors.missing-data' });
const link = await DiscordGuildLink.findOne({ guildId: req.params.guildId }).lean();
if (!link) return res.json({ status: 'error', msg: 'discord.errors.not-connected' });
const campaigns = await Campaign.find({ createdBy: link.dragonrollUser })
.select('_id name discordGuildId')
.sort({ date: -1 })
.lean();
res.json({ status: 'ok', campaigns });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
router.post('/bot/guild/:guildId/campaign', requireBot, async (req, res) => {
try {
const guildId = String(req.params.guildId);
if (!validGuildId(guildId) || !req.body.campaignId) return res.json({ status: 'error', msg: 'errors.missing-data' });
const link = await DiscordGuildLink.findOne({ guildId }).lean();
if (!link) return res.json({ status: 'error', msg: 'discord.errors.not-connected' });
const campaign = await Campaign.findOne({ _id: req.body.campaignId, createdBy: link.dragonrollUser });
if (!campaign) return res.json({ status: 'error', msg: 'errors.notfound' });
const conflict = await Campaign.findOne({ discordGuildId: guildId, _id: { $ne: campaign._id } }).lean();
if (conflict && String(conflict.createdBy) !== String(link.dragonrollUser)) {
return res.json({ status: 'error', msg: 'campaigns.errors.discord-guild-in-use' });
}
if (campaign.discordGuildId && campaign.discordGuildId !== guildId) {
return res.json({ status: 'error', msg: 'discord.errors.campaign-already-linked' });
}
await Campaign.updateMany(
{ discordGuildId: guildId, createdBy: link.dragonrollUser, _id: { $ne: campaign._id } },
{ $unset: { discordGuildId: 1 } }
);
campaign.discordGuildId = guildId;
await campaign.save();
res.json({ status: 'ok', campaign: { id: String(campaign._id), name: campaign.name } });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
router.delete('/bot/guild/:guildId/campaign', requireBot, async (req, res) => {
try {
const guildId = String(req.params.guildId);
if (!validGuildId(guildId)) return res.json({ status: 'error', msg: 'errors.missing-data' });
const link = await DiscordGuildLink.findOne({ guildId }).lean();
if (!link) return res.json({ status: 'error', msg: 'discord.errors.not-connected' });
const campaign = await Campaign.findOne({ discordGuildId: guildId, createdBy: link.dragonrollUser });
if (!campaign) return res.json({ status: 'error', msg: 'errors.notfound' });
campaign.discordGuildId = undefined;
await campaign.save();
res.json({ status: 'ok', campaign: { id: String(campaign._id), name: campaign.name } });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
router.get('/bot/guild/:guildId/actors', requireBot, async (req, res) => {
try {
const guildId = String(req.params.guildId);
if (!validGuildId(guildId)) return res.json({ status: 'error', msg: 'errors.missing-data' });
const link = await DiscordGuildLink.findOne({ guildId }).lean();
if (!link) return res.json({ status: 'error', msg: 'discord.errors.not-connected' });
const campaign = await Campaign.findOne({ discordGuildId: guildId, createdBy: link.dragonrollUser }).select('_id name').lean();
if (!campaign) return res.json({ status: 'error', msg: 'errors.notfound' });
const actors = await Actor.find({ campaign: campaign._id }).sort({ name: 1 }).lean();
res.json({ status: 'ok', campaign: { id: String(campaign._id), name: campaign.name }, actors });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
module.exports = router;