All checks were successful
Build and Deploy Nuxt / build (push) Successful in 1m51s
273 lines
11 KiB
JavaScript
273 lines
11 KiB
JavaScript
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;
|