Fix issue #19: Add unified campaign sync

This commit is contained in:
Gitea OpenCode Agent
2026-10-14 14:07:52 +00:00
parent 9d9738b2b4
commit 0a8452b3c8
22 changed files with 1469 additions and 921 deletions

View File

@@ -1,24 +1,28 @@
const express = require('express')
const router = express.Router();
const crypto = require('node:crypto');
const Campaign = require("../models/Campaign");
const FoundryLinkRequest = require('../models/FoundryLinkRequest');
const User = require('../models/User');
const serviceLinks = require('../services/service-links');
const FOUNDRY_LINK_TTL_MS = 10 * 60 * 1000;
// Every service links to a campaign through the same sign-up link
// (routes/service-link.js); a campaign only drops one of them again.
async function unlinkService(campaign, service) {
if (service === 'foundry') {
campaign.foundryWorldId = undefined;
campaign.foundryWorldTitle = undefined;
campaign.foundrySystem = undefined;
campaign.set('foundrySyncTokenHash', undefined);
} else if (service === 'discord') {
// The Discord account the bot answers to stays: the server is simply
// left without a campaign until somebody picks one again.
campaign.discordGuildId = undefined;
}
function foundryCodeHash(code) {
return crypto.createHash('sha256').update(String(code ?? '').trim()).digest('hex');
}
async function expirePendingFoundryLinks(campaignId, userId) {
const filter = {
source: 'dragonroll',
campaign: campaignId,
createdBy: userId,
completedAt: null
};
await FoundryLinkRequest.updateMany(filter, { $set: { expiresAt: new Date() } });
await campaign.save();
// A link a service still holds becomes invalid, and it finds that out the
// next time it asks where its link stands.
await serviceLinks.revokeServiceLink(service, campaign._id);
}
router.post('/create', async (req, res) => {
@@ -74,73 +78,26 @@ router.post('/update', async (req, res) => {
}
});
router.post('/foundry-link/start', async (req, res) => {
try {
const campaign = await Campaign.findOne({ _id: req.body.campaignId, createdBy: req.user.id });
if (!campaign) return res.json({ status: 'error', msg: 'errors.notfound' });
await expirePendingFoundryLinks(campaign._id, req.user.id);
const code = crypto.randomBytes(24).toString('base64url');
const expiresAt = new Date(Date.now() + FOUNDRY_LINK_TTL_MS);
const request = await FoundryLinkRequest.create({
codeHash: foundryCodeHash(code),
code,
source: 'dragonroll',
campaign: campaign._id,
createdBy: req.user.id,
expiresAt
});
res.set('Cache-Control', 'no-store');
res.json({ status: 'ok', code, requestId: request.id, expiresAt });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
router.get('/foundry-link/status/:requestId', async (req, res) => {
try {
const request = await FoundryLinkRequest.findOne({
_id: req.params.requestId,
source: 'dragonroll',
createdBy: req.user.id
});
if (!request) return res.json({ status: 'ok', state: 'expired' });
if (!request.completedAt && request.expiresAt <= new Date()) {
return res.json({ status: 'ok', state: 'expired' });
}
if (!request.completedAt) return res.json({ status: 'ok', state: 'pending' });
const campaign = await Campaign.findOne({ _id: request.campaign, createdBy: req.user.id });
if (!campaign) return res.json({ status: 'error', msg: 'errors.notfound' });
res.json({ status: 'ok', state: 'complete', campaign });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
// Returns the still-valid pending pairing request for a campaign, so the
// settings window can restore its pairing code across reloads and restarts.
router.get('/foundry-link/pending', async (req, res) => {
// Which services a campaign has connected, and the account each of them was
// authorized with.
router.get('/services', async (req, res) => {
try {
const campaign = await Campaign.findOne({ _id: req.query.campaignId, createdBy: req.user.id });
if (!campaign) return res.json({ status: 'error', msg: 'errors.notfound' });
const request = await FoundryLinkRequest.findOne({
source: 'dragonroll',
campaign: campaign._id,
createdBy: req.user.id,
completedAt: null,
expiresAt: { $gt: new Date() }
}).sort({ createdAt: -1 });
if (!request) return res.json({ status: 'ok', request: null });
const links = await serviceLinks.listLinkedServices(campaign._id);
const userIds = [...new Set(links.map((link) => String(link.dragonrollUser ?? '')).filter(Boolean))];
const users = userIds.length
? await User.find({ _id: { $in: userIds } }).select('username name').lean()
: [];
const names = new Map(users.map((user) => [String(user._id), user.username || user.name]));
res.set('Cache-Control', 'no-store');
res.json({
status: 'ok',
request: { requestId: request.id, code: request.code, expiresAt: request.expiresAt }
services: links.map((link) => ({
...link,
dragonrollUserName: names.get(String(link.dragonrollUser ?? '')) || null
}))
});
} catch (err) {
console.error(err);
@@ -148,18 +105,16 @@ router.get('/foundry-link/pending', async (req, res) => {
}
});
router.post('/foundry-unlink', async (req, res) => {
router.post('/service-unlink', async (req, res) => {
try {
const service = String(req.body.service || '').trim();
if (!serviceLinks.isService(service)) return res.json({ status: 'error', msg: 'errors.missing-data' });
const campaign = await Campaign.findOne({ _id: req.body.campaignId, createdBy: req.user.id });
if (!campaign) return res.json({ status: 'error', msg: 'errors.notfound' });
campaign.foundryWorldId = undefined;
campaign.foundryWorldTitle = undefined;
campaign.foundrySystem = undefined;
campaign.set('foundrySyncTokenHash', undefined);
await campaign.save();
await expirePendingFoundryLinks(campaign._id, req.user.id);
res.json({ status: 'ok', campaign });
await unlinkService(campaign, service);
res.json({ status: 'ok', campaign, services: await serviceLinks.listLinkedServices(campaign._id) });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });

View File

@@ -1,124 +1,25 @@
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 ServiceLinkRequest = require('../models/ServiceLinkRequest');
const User = require('../models/User');
const serviceLinks = require('../services/service-links');
const LINK_TTL_MS = 10 * 60 * 1000;
const NOTIFICATION_WINDOW_MS = 15 * 60 * 1000;
const NOTIFICATION_LIMIT = 10;
const requireBot = serviceLinks.requireDiscordBot;
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' });
}
});
// Connecting a Discord server is the service link of issue: the bot asks
// /api/link/start for a sign-up link, and whoever opens it signs in and picks the
// campaign this server may read. What is left here is what the bot needs once
// that link exists: confirming it in Discord and working with its campaign.
async function dragonrollUserNames(requests) {
const userIds = [...new Set(requests.map((request) => String(request.dragonrollUser ?? '')).filter(Boolean))];
@@ -132,16 +33,18 @@ async function dragonrollUserNames(requests) {
// 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) },
const pending = await ServiceLinkRequest.find({
service: 'discord',
state: 'linked',
linkedAt: { $gte: new Date(Date.now() - serviceLinks.NOTIFICATION_WINDOW_MS) },
notifiedAt: null
}).select('_id guildId guildName discordUserId discordUserName dragonrollUser')
}).select('_id targetId targetName targetUser targetMeta dragonrollUser campaign')
.limit(NOTIFICATION_LIMIT)
.lean();
const claimed = [];
for (const request of pending) {
const taken = await DiscordLinkRequest.findOneAndUpdate(
const taken = await ServiceLinkRequest.findOneAndUpdate(
{ _id: request._id, notifiedAt: null },
{ $set: { notifiedAt: new Date() } },
{ new: true }
@@ -150,15 +53,22 @@ router.post('/bot/link-requests/notifications', requireBot, async (req, res) =>
}
const names = await dragonrollUserNames(claimed);
const campaignIds = [...new Set(claimed.map((request) => String(request.campaign ?? '')).filter(Boolean))];
const campaigns = campaignIds.length
? await Campaign.find({ _id: { $in: campaignIds } }).select('_id name').lean()
: [];
const campaignNames = new Map(campaigns.map((campaign) => [String(campaign._id), campaign.name]));
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
guildId: request.targetId,
guildName: request.targetName,
discordUserId: request.targetMeta?.userId || '',
discordUserName: request.targetUser,
dragonrollUserName: names.get(String(request.dragonrollUser ?? '')) || null,
campaignName: campaignNames.get(String(request.campaign ?? '')) || null
}))
});
} catch (err) {

View File

@@ -1,18 +1,14 @@
const crypto = require('node:crypto');
const express = require('express');
const rateLimit = require('express-rate-limit');
const mongoose = require('mongoose');
const router = express.Router();
const Campaign = require('../models/Campaign');
const Actor = require('../models/Actor');
const Item = require('../models/Item');
const FoundryLinkRequest = require('../models/FoundryLinkRequest');
const { foundryActorToCharacter } = require('../services/actor-foundry');
const { foundryItemToItemData } = require('../services/item-foundry');
const linkRateLimit = rateLimit({ windowMs: 15 * 60 * 1000, max: 20 });
// Upper bound for the Foundry names remembered per synced item (see Item model).
const MAX_FOUNDRY_NAMES = 20;
@@ -129,113 +125,9 @@ async function syncFoundryItems(campaign, sources, fullSync = false) {
return items;
}
function readWorld(body) {
const world = body?.world;
if (!world || typeof world.id !== 'string' || !world.id.trim()) return null;
let foundryUrl = '';
if (typeof world.url === 'string') {
try {
const url = new URL(world.url);
if (url.protocol === 'http:' || url.protocol === 'https:') foundryUrl = url.origin;
} catch {}
}
return {
worldId: world.id.trim().slice(0, 120),
worldTitle: typeof world.title === 'string' ? world.title.trim().slice(0, 200) : '',
system: typeof world.system === 'string' ? world.system.trim().slice(0, 120) : '',
foundryUrl
};
}
async function attachWorldToCampaign(campaign, world) {
const linkedElsewhere = await Campaign.findOne({
foundryWorldId: world.worldId,
_id: { $ne: campaign._id }
}).select('_id');
if (linkedElsewhere) return false;
campaign.foundryWorldId = world.worldId;
campaign.foundryWorldTitle = world.worldTitle;
campaign.foundrySystem = world.system;
if (world.foundryUrl) {
const settings = campaign.settings && typeof campaign.settings === 'object' ? campaign.settings : {};
const integrations = settings.integrations && typeof settings.integrations === 'object'
? settings.integrations
: {};
campaign.settings = {
...settings,
integrations: {
...integrations,
foundryUrl: integrations.foundryUrl || world.foundryUrl
}
};
}
await campaign.save();
return true;
}
async function expireOtherPendingLinks(campaignId, userId, requestId) {
await FoundryLinkRequest.updateMany({
source: 'dragonroll',
campaign: campaignId,
createdBy: userId,
completedAt: null,
_id: { $ne: requestId }
}, { $set: { expiresAt: new Date() } });
}
router.post('/link/complete', linkRateLimit, async (req, res) => {
try {
const world = readWorld(req.body);
if (!world || typeof req.body.code !== 'string' || !req.body.code.trim()) {
return res.json({ status: 'error', msg: 'errors.missing-data' });
}
const request = await FoundryLinkRequest.findOne({
codeHash: codeHash(req.body.code),
source: 'dragonroll',
expiresAt: { $gt: new Date() },
completedAt: null
});
if (!request) return res.json({ status: 'error', msg: 'foundry.errors.link-expired' });
const campaign = await Campaign.findOne({ _id: request.campaign, createdBy: request.createdBy });
if (!campaign) return res.json({ status: 'error', msg: 'errors.notfound' });
const attached = await attachWorldToCampaign(campaign, world);
if (!attached) return res.json({ status: 'error', msg: 'foundry.errors.world-already-linked' });
const syncToken = crypto.randomBytes(32).toString('base64url');
campaign.foundrySyncTokenHash = codeHash(syncToken);
await campaign.save();
request.worldId = world.worldId;
request.worldTitle = world.worldTitle;
request.system = world.system;
request.foundryUrl = world.foundryUrl;
request.completedAt = new Date();
request.code = undefined; // Redeemed: keep only the hash from now on.
await request.save();
await expireOtherPendingLinks(campaign._id, request.createdBy, request._id);
const bridgeUrl = process.env.FOUNDRY_API_CLIENT_URL || process.env.FOUNDRY_API_URL;
const pushToken = process.env.FOUNDRY_API_PUSH_TOKEN;
res.set('Cache-Control', 'no-store');
res.json({
status: 'ok',
campaign: { id: campaign.id, name: campaign.name },
world: { id: world.worldId, title: world.worldTitle, system: world.system },
syncToken,
bridgeConfig: bridgeUrl && pushToken ? { url: bridgeUrl, pushToken } : null
});
} catch (err) {
console.error(err);
if (err.code === 11000) return res.json({ status: 'error', msg: 'foundry.errors.world-already-linked' });
res.json({ status: 'error', msg: 'errors.internal' });
}
});
// Linking a world to a campaign happens through the sign-up link every service
// uses (routes/service-link.js); what stays here is the sync that world keeps up
// with the campaign once that link has handed it its token.
// The Foundry module shows this in its settings: the sync token alone only proves
// a link was made once, so the module asks which campaign it belongs to and hears

View File

@@ -0,0 +1,209 @@
const crypto = require('node:crypto');
const express = require('express');
const jwt = require('jsonwebtoken');
const passport = require('passport');
const rateLimit = require('express-rate-limit');
const router = express.Router();
const Campaign = require('../models/Campaign');
const DiscordGuildLink = require('../models/DiscordGuildLink');
const secret = require('../services/keys').secret;
const serviceLinks = require('../services/service-links');
const linkRateLimit = rateLimit({ windowMs: 15 * 60 * 1000, max: 40 });
const GUILD_ID = /^\d{5,25}$/;
// What the sign-up screen shows about the request behind a code.
function publicRequest(request) {
return {
service: request.service,
serviceName: serviceLinks.serviceName(request.service),
targetName: request.targetName,
targetUser: request.targetUser,
system: request.targetMeta?.system || '',
expiresAt: request.expiresAt
};
}
// A session for a service that keeps working once the browser which authorised
// it is gone: Obsidian gets the same kind of session signing in gives, so its
// notes keep travelling over the routes they always used.
function userSession(user) {
const payload = {
_id: user._id,
username: user.username,
name: user.name,
email: user.email,
admin: user.admin,
settings: user.settings
};
return jwt.sign(payload, secret, { expiresIn: 172800 });
}
// A Foundry world tells Dragonroll who it is when it asks for its link, so the
// user only has to say which campaign the world may work on.
async function completeFoundryLink(campaign, request) {
const linkedElsewhere = await Campaign.findOne({
foundryWorldId: request.targetId,
_id: { $ne: campaign._id }
}).select('_id');
if (linkedElsewhere) return { msg: 'foundry.errors.world-already-linked' };
campaign.foundryWorldId = request.targetId;
campaign.foundryWorldTitle = request.targetName;
campaign.foundrySystem = request.targetMeta?.system || '';
const settings = campaign.settings && typeof campaign.settings === 'object' ? campaign.settings : {};
const integrations = settings.integrations && typeof settings.integrations === 'object' ? settings.integrations : {};
const foundryUrl = request.targetMeta?.url || '';
if (foundryUrl && !integrations.foundryUrl) {
campaign.settings = { ...settings, integrations: { ...integrations, foundryUrl } };
}
const syncToken = crypto.randomBytes(32).toString('base64url');
campaign.foundrySyncTokenHash = serviceLinks.codeHash(syncToken);
await campaign.save();
const bridgeUrl = process.env.FOUNDRY_API_CLIENT_URL || process.env.FOUNDRY_API_URL;
const pushToken = process.env.FOUNDRY_API_PUSH_TOKEN;
return {
credentials: {
syncToken,
bridgeConfig: bridgeUrl && pushToken ? { url: bridgeUrl, pushToken } : null
}
};
}
// The Discord account behind the request is the one the bot answers to; a new
// authorization takes the server over from whoever held it before.
async function completeDiscordLink(campaign, request, user) {
await Campaign.updateMany(
{ discordGuildId: request.targetId, createdBy: { $ne: user.id } },
{ $unset: { discordGuildId: 1 } }
);
await DiscordGuildLink.findOneAndUpdate({ guildId: request.targetId }, {
$set: {
discordUserId: request.targetMeta?.userId || request.targetId,
dragonrollUser: user.id,
connectedAt: new Date()
}
}, { new: true, upsert: true, setDefaultsOnInsert: true });
campaign.discordGuildId = request.targetId;
await campaign.save();
}
// A service asks for a sign-up link and shows it to whoever is sitting in front
// of it. Nothing is linked until a Dragonroll user opens that link, signs in and
// picks one of their campaigns.
router.post('/start', linkRateLimit, async (req, res) => {
try {
const service = String(req.body.service || '').trim();
if (!serviceLinks.isService(service)) return res.json({ status: 'error', msg: 'link.errors.unknown-service' });
// A service that can prove who it is gets its link checked: a Discord
// server is claimed by whoever runs the bot, not by whoever knows its id.
if (serviceLinks.isBotOnly(service) && !serviceLinks.isDiscordBot(req)) {
return res.status(401).json({ status: 'error', msg: 'errors.unauthorized' });
}
const target = serviceLinks.readTarget(req.body);
if (!target.targetId) return res.json({ status: 'error', msg: 'errors.missing-data' });
if (service === 'discord' && (!GUILD_ID.test(target.targetId) || !target.targetName || !target.targetUser)) {
return res.json({ status: 'error', msg: 'errors.missing-data' });
}
const link = await serviceLinks.startServiceLink(service, target);
res.set('Cache-Control', 'no-store');
res.json({ status: 'ok', service, code: link.code, linkUrl: link.url, expiresAt: link.expiresAt });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
// What a sign-up link is about, so the screen can name the world, Discord server
// or vault that is waiting, and the person who asked.
router.post('/details', async (req, res) => {
try {
res.set('Cache-Control', 'no-store');
const request = await serviceLinks.findServiceLinkByCode(req.body.code);
if (!request || serviceLinks.linkIsExpired(request)) {
return res.json({ status: 'error', msg: 'link.errors.expired' });
}
res.json({ status: 'ok', ...publicRequest(request) });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
// The user who signs in through a link owns the campaigns listed there, so
// picking one of them is the whole authorization.
router.post('/complete', passport.authenticate('jwt', { session: false }), async (req, res) => {
try {
res.set('Cache-Control', 'no-store');
const request = await serviceLinks.findServiceLinkByCode(req.body.code);
if (!request || serviceLinks.linkIsExpired(request)) {
return res.json({ status: 'error', msg: 'link.errors.expired' });
}
const campaign = await Campaign.findOne({ _id: req.body.campaignId, createdBy: req.user.id });
if (!campaign) return res.json({ status: 'error', msg: 'errors.notfound' });
if (request.service === 'discord' && campaign.discordGuildId && campaign.discordGuildId !== request.targetId) {
return res.json({ status: 'error', msg: 'discord.errors.campaign-already-linked' });
}
if (request.service === 'foundry') {
const linked = await completeFoundryLink(campaign, request);
if (linked.msg) return res.json({ status: 'error', msg: linked.msg });
await serviceLinks.completeServiceLink(request, campaign, req.user, linked.credentials);
} else if (request.service === 'discord') {
await completeDiscordLink(campaign, request, req.user);
await serviceLinks.completeServiceLink(request, campaign, req.user);
} else {
await serviceLinks.completeServiceLink(request, campaign, req.user, { token: userSession(req.user) });
}
res.json({ status: 'ok', service: request.service, campaign: { id: campaign.id, name: campaign.name } });
} catch (err) {
console.error(err);
if (err.code === 11000) return res.json({ status: 'error', msg: 'foundry.errors.world-already-linked' });
res.json({ status: 'error', msg: 'errors.internal' });
}
});
// Where a link stands, and what the service that asked for it gets out of it.
// A credential is delivered once: a service that loses it asks for a new link.
router.post('/pickup', async (req, res) => {
try {
res.set('Cache-Control', 'no-store');
const request = await serviceLinks.findServiceLinkByCode(req.body.code);
if (!request || serviceLinks.linkIsExpired(request)) {
return res.json({ status: 'ok', state: 'expired' });
}
if (request.state !== 'linked') {
return res.json({ status: 'ok', state: request.state, campaign: null });
}
const campaign = await Campaign.findOne({ _id: request.campaign }).select('_id name').lean();
const credentials = await serviceLinks.takeServiceLinkCredentials(request);
res.json({
status: 'ok',
state: 'linked',
service: request.service,
campaign: campaign ? { id: String(campaign._id), name: campaign.name } : null,
syncToken: credentials?.syncToken || '',
bridgeConfig: credentials?.bridgeConfig || null,
token: credentials?.token || ''
});
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
module.exports = router;