Files
crosscode-platform/apps/events/backend/src/utils/privacy.js
T
joshuaandClaude Opus 5.5 dbec47aae3 WIP 2.0.0: AI helper plumbing (status, usage, Site settings -> AI)
The site calls AI through the Hub (protocol 3b, Hub 1.6.0): src/ai
works out whether the AI buttons show (licence token first, then the
Hub, cached a minute), runs a helper call with per-helper switches and
a per-person daily limit, logs AiCall rows, and emails admins at 80%.
v2 /ai/status, /ai/usage, /ai/settings; useAiStatus, AiButton, AiTab.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-30 09:25:36 +02:00

680 lines
33 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/**
* POPIA toolkit, the data subject side: news opt-in and its consent log, unsubscribe
* links, the opt-out filter every bulk send goes through, anonymising an account, and
* "Download my data".
*
* Bulk messages come in two kinds:
* - 'update' — about an event the person registered for (venue change, reminder). Sent
* regardless of the news opt-in; the email links to the preferences.
* - 'news' — News & announcements (marketing). Only to people who opted in on that
* channel, never to an address that unsubscribed, with a one-click unsubscribe.
*/
const crypto = require('crypto');
const prisma = require('../config/db');
const CHANNELS = ['email', 'whatsapp'];
const MESSAGE_KINDS = ['update', 'news'];
// POPIA gives a responsible party 30 days to respond to a request.
const REQUEST_DUE_DAYS = 30;
const DELETED_NAME = 'Deleted User';
const DELETED_ATTENDEE_NAME = 'Deleted attendee';
function frontendUrl() {
return String(process.env.FRONTEND_URL || process.env.APP_BASE_URL || 'http://localhost:3001').replace(/\/$/, '');
}
function backendUrl() {
return String(process.env.BACKEND_URL || process.env.API_URL || 'http://localhost:5000').replace(/\/$/, '');
}
function normaliseKind(kind) {
return MESSAGE_KINDS.includes(kind) ? kind : null;
}
function normaliseEmail(email) {
return String(email || '').trim().toLowerCase();
}
function addressFor(channel, raw) {
if (channel === 'whatsapp') return require('./whatsapp').normalizeZAPhone(raw) || null;
return normaliseEmail(raw) || null;
}
// ─── News opt-in ──────────────────────────────────────────────────────────────
const NEWS_FIELD = { email: 'newsEmail', whatsapp: 'newsWhatsApp' };
/**
* Set someone's news opt-in. `prefs` is { email?, whatsapp? } (booleans; missing = leave).
* Logs one CommunicationConsent row per channel that actually changed — or every channel
* given when `logAll` (the first answer to the opt-in question is worth recording even
* when it keeps the current value). WhatsApp can't be switched on without a valid phone.
*/
async function setNewsPreferences(userId, prefs, { source, ip = null, answered = false, logAll = false } = {}, db = prisma) {
const user = await db.user.findUnique({ where: { id: userId }, select: { id: true, phoneNumber: true, newsEmail: true, newsWhatsApp: true } });
if (!user) return null;
const { isValidZAPhone } = require('./whatsapp');
const data = {};
const log = [];
for (const channel of CHANNELS) {
if (typeof prefs?.[channel] !== 'boolean') continue;
let value = prefs[channel];
if (channel === 'whatsapp' && value && !isValidZAPhone(user.phoneNumber)) value = false;
const field = NEWS_FIELD[channel];
if (value !== user[field]) data[field] = value;
if (value !== user[field] || logAll) log.push({ userId, channel, granted: value, source, ip });
}
if (answered) data.newsAskedAt = new Date();
const updated = Object.keys(data).length
? await db.user.update({ where: { id: userId }, data, select: { newsEmail: true, newsWhatsApp: true, newsAskedAt: true } })
: await db.user.findUnique({ where: { id: userId }, select: { newsEmail: true, newsWhatsApp: true, newsAskedAt: true } });
if (log.length) await db.communicationConsent.createMany({ data: log });
return updated;
}
/** The consent history for one person, newest first. */
function consentHistory(userId, db = prisma) {
return db.communicationConsent.findMany({
where: { userId },
orderBy: { createdAt: 'desc' },
select: { id: true, channel: true, granted: true, source: true, createdAt: true },
});
}
// ─── Unsubscribe links ────────────────────────────────────────────────────────
// A token names an account (u) or, for people without one, an address on a channel (a, c).
// Signed with JWT_SECRET and never expires: an unsubscribe link must keep working.
function sign(payload) {
return crypto.createHmac('sha256', process.env.JWT_SECRET || '').update(`unsubscribe:${payload}`).digest('base64url').slice(0, 32);
}
function unsubscribeToken(target) {
const body = target.userId ? { u: target.userId } : { a: target.address, c: target.channel };
const payload = Buffer.from(JSON.stringify(body)).toString('base64url');
return `${payload}.${sign(payload)}`;
}
/** { userId } or { address, channel } for a valid token, else null. */
function readUnsubscribeToken(token) {
const [payload, sig] = String(token || '').split('.');
if (!payload || !sig) return null;
const expected = sign(payload);
if (sig.length !== expected.length || !crypto.timingSafeEqual(Buffer.from(sig), Buffer.from(expected))) return null;
try {
const body = JSON.parse(Buffer.from(payload, 'base64url').toString('utf8'));
if (typeof body.u === 'string' && body.u) return { userId: body.u };
if (typeof body.a === 'string' && body.a && CHANNELS.includes(body.c)) return { address: body.a, channel: body.c };
} catch { /* fall through */ }
return null;
}
/** The page people land on from an unsubscribe link. */
function unsubscribePageUrl(target) {
return `${frontendUrl()}/unsubscribe?t=${encodeURIComponent(unsubscribeToken(target))}`;
}
/** RFC 8058 one-click endpoint, for the List-Unsubscribe header (mail apps POST to it). */
function oneClickUrl(target) {
return `${backendUrl()}/api/v2/unsubscribe/${encodeURIComponent(unsubscribeToken(target))}/one-click`;
}
/** What an unsubscribe link refers to, for the landing page. */
async function describeUnsubscribe(token) {
const target = readUnsubscribeToken(token);
if (!target) return null;
if (target.userId) {
const user = await prisma.user.findUnique({ where: { id: target.userId }, select: { email: true, phoneNumber: true, newsEmail: true, newsWhatsApp: true, isActive: true } });
if (!user) return null;
return {
kind: 'account',
email: maskEmail(user.email),
hasPhone: !!user.phoneNumber,
news: { email: user.newsEmail, whatsapp: user.newsWhatsApp },
};
}
const optedOut = !!(await prisma.messagingOptOut.findUnique({ where: { channel_address: { channel: target.channel, address: target.address } } }));
return {
kind: 'address',
channel: target.channel,
address: target.channel === 'email' ? maskEmail(target.address) : maskPhone(target.address),
optedOut,
};
}
/**
* Unsubscribe from news. For an account: the given channels (default both). For an
* address: that address on its channel. Returns the new state, or null for a bad token.
*/
async function unsubscribe(token, { channels = CHANNELS, source = 'unsubscribe_link', ip = null } = {}) {
const target = readUnsubscribeToken(token);
if (!target) return null;
if (target.userId) {
const prefs = {};
for (const c of channels) if (CHANNELS.includes(c)) prefs[c] = false;
return setNewsPreferences(target.userId, prefs, { source, ip });
}
await optOutAddress(target.channel, target.address, { source, ip });
return { optedOut: true };
}
/** Record that an address without an account wants no more news on a channel. */
async function optOutAddress(channel, rawAddress, { source, ip = null } = {}, db = prisma) {
const address = addressFor(channel, rawAddress);
if (!address) return false;
const existing = await db.messagingOptOut.findUnique({ where: { channel_address: { channel, address } } });
if (existing) return true;
await db.messagingOptOut.create({ data: { channel, address, source } });
await db.communicationConsent.create({ data: { address, channel, granted: false, source, ip } });
return true;
}
function maskEmail(email) {
const [local, domain] = String(email || '').split('@');
if (!domain) return '';
return `${local.slice(0, 2)}${'*'.repeat(Math.max(1, local.length - 2))}@${domain}`;
}
function maskPhone(phone) {
const s = String(phone || '');
return s.length > 4 ? `${'*'.repeat(s.length - 4)}${s.slice(-4)}` : s;
}
// ─── Bulk sends ───────────────────────────────────────────────────────────────
/**
* Drop recipients a news message mustn't go to. `recipients` are { email } (channel
* 'email') or { phone } (channel 'whatsapp'), optionally with userId. Removed: accounts on
* that address without the news opt-in for the channel, and addresses that unsubscribed.
* Each kept recipient gets `userId` filled in when the address belongs to an account, so
* the email footer can link to the account's preferences. Update messages pass through
* untouched (apart from the userId lookup). Returns { recipients, skipped }.
*/
async function filterRecipients(recipients, { channel, kind }, db = prisma) {
const key = channel === 'whatsapp' ? 'phone' : 'email';
const addressOf = r => addressFor(channel, r[key]);
const addresses = [...new Set(recipients.map(addressOf).filter(Boolean))];
if (!addresses.length) return { recipients: [], skipped: recipients.length };
const users = await db.user.findMany({
where: channel === 'whatsapp'
? { phoneNumber: { in: addresses } }
: { OR: addresses.map(a => ({ email: { equals: a, mode: 'insensitive' } })) },
select: { id: true, email: true, phoneNumber: true, newsEmail: true, newsWhatsApp: true },
});
const byAddress = new Map(users.map(u => [addressFor(channel, channel === 'whatsapp' ? u.phoneNumber : u.email), u]));
let optedOut = new Set();
if (kind === 'news') {
const rows = await db.messagingOptOut.findMany({ where: { channel, address: { in: addresses } }, select: { address: true } });
optedOut = new Set(rows.map(r => r.address));
}
const kept = [];
for (const r of recipients) {
const address = addressOf(r);
const user = address ? byAddress.get(address) : null;
if (kind === 'news') {
if (!address || optedOut.has(address)) continue;
if (user && !user[NEWS_FIELD[channel]]) continue;
}
kept.push({ ...r, userId: r.userId || user?.id || null });
}
return { recipients: kept, skipped: recipients.length - kept.length };
}
function escapeHtml(s) {
return String(s || '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
}
/**
* The footer and headers a bulk email gets. News: unsubscribe link + List-Unsubscribe
* (one click in Gmail/Apple Mail). Updates: why they got it, and where to manage
* preferences. Returns { html, text, headers }.
*/
function bulkEmailFooter({ kind, recipient, eventTitle = '' }) {
const prefsUrl = `${frontendUrl()}/dashboard/user/privacy`;
const style = 'color:#94a3b8;font-size:12px;line-height:1.6;margin:24px 0 0 0;border-top:1px solid #e2e8f0;padding-top:12px';
if (kind === 'news') {
const target = recipient.userId ? { userId: recipient.userId } : { address: normaliseEmail(recipient.email), channel: 'email' };
const url = unsubscribePageUrl(target);
return {
html: `<p style="${style}">You're receiving this because you chose to get news and announcements from us. <a href="${url}" style="color:#64748b">Unsubscribe</a>${recipient.userId ? ` &middot; <a href="${prefsUrl}" style="color:#64748b">Manage preferences</a>` : ''}</p>`,
text: `\n\n—\nYou're receiving this because you chose to get news and announcements from us.\nUnsubscribe: ${url}`,
headers: {
'List-Unsubscribe': `<${oneClickUrl(target)}>`,
'List-Unsubscribe-Post': 'List-Unsubscribe=One-Click',
},
};
}
const why = eventTitle ? `you registered for ${eventTitle}` : 'you have a registration or account with us';
return {
html: `<p style="${style}">You're receiving this because ${escapeHtml(why)}. <a href="${prefsUrl}" style="color:#64748b">Manage your communication preferences</a></p>`,
text: `\n\n—\nYou're receiving this because ${why}.\nManage your communication preferences: ${prefsUrl}`,
headers: {},
};
}
/** The line a bulk news WhatsApp ends with. */
function whatsAppNewsFooter(recipient) {
const target = recipient.userId ? { userId: recipient.userId } : { address: addressFor('whatsapp', recipient.phone), channel: 'whatsapp' };
return `\n\n_Reply STOP to stop news messages, or unsubscribe: ${unsubscribePageUrl(target)}_`;
}
/** Recognises an opt-out reply ("STOP", "stop.", "Unsubscribe"). */
function isStopKeyword(text) {
return /^\s*(stop|unsubscribe|stop all|opt out|optout)\s*[.!]?\s*$/i.test(String(text || ''));
}
/**
* Someone replied STOP on WhatsApp: no more news on WhatsApp for that number — the
* account's opt-in if the number belongs to one, otherwise the number itself.
* Returns 'account' | 'address' | null (number not usable).
*/
async function whatsAppStop(rawPhone) {
const phone = addressFor('whatsapp', rawPhone);
if (!phone) return null;
const user = await prisma.user.findFirst({ where: { phoneNumber: phone }, select: { id: true } });
if (user) {
await setNewsPreferences(user.id, { whatsapp: false }, { source: 'whatsapp_stop' });
return 'account';
}
await optOutAddress('whatsapp', phone, { source: 'whatsapp_stop' });
return 'address';
}
// ─── Data requests ────────────────────────────────────────────────────────────
function dueDate(from = new Date()) {
return new Date(from.getTime() + REQUEST_DUE_DAYS * 24 * 60 * 60 * 1000);
}
async function createDataRequest({ user, type, details = null, selfService = false }, db = prisma) {
const now = new Date();
return db.dataRequest.create({
data: {
type,
userId: user.id,
name: user.name,
email: user.email,
details: details ? String(details).slice(0, 5000) : null,
selfService,
status: selfService ? 'completed' : 'open',
closedAt: selfService ? now : null,
dueAt: dueDate(now),
},
});
}
/** Who hears about privacy requests: the Information Officer (when set) and every admin. */
async function privacyContacts(db = prisma) {
const { getSettingSync } = require('./settingsCache');
const admins = await db.user.findMany({ where: { role: 'admin', isActive: true }, select: { email: true } });
const io = getSettingSync('legal_io_email', '');
return [...new Set([...(io && !io.endsWith('@example.com') ? [io] : []), ...admins.map(a => a.email)])];
}
/**
* Daily: email the Information Officer and admins a list of open requests due within 7 days
* or overdue. Nothing is sent when there are none.
*/
async function remindDueRequests(now = new Date(), db = prisma) {
const soon = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1000);
const due = await db.dataRequest.findMany({
where: { status: 'open', selfService: false, dueAt: { lte: soon } },
orderBy: { dueAt: 'asc' },
select: { type: true, name: true, dueAt: true },
});
if (!due.length) return { due: 0, notified: 0 };
const { sendMail, buildPrivacyEmail } = require('./email');
const to = await privacyContacts(db);
const fmt = d => d.toLocaleDateString('en-ZA', { timeZone: 'Africa/Johannesburg' });
const content = buildPrivacyEmail({
name: '',
heading: 'Privacy requests need an answer',
paragraphs: [
`${due.length} privacy request${due.length === 1 ? ' is' : 's are'} due within a week or overdue. POPIA asks for an answer within 30 days.`,
due.map(r => `${r.dueAt < now ? 'OVERDUE' : `Due ${fmt(r.dueAt)}`} — ${r.type} request from ${r.name}`).join('\n'),
`Handle them on the Data requests page: ${frontendUrl()}/dashboard/admin/data-requests`,
],
});
await Promise.allSettled(to.map(email => sendMail({ to: email, subject: 'Privacy requests need an answer', ...content })));
return { due: due.length, notified: to.length };
}
/**
* Why an account can't be anonymised yet: registrations (not cancelled) for events that
* haven't ended. The person may still need the ticket, or be owed or owe money.
*/
async function deletionBlockers(userId, db = prisma) {
const regs = await db.registration.findMany({
where: { userId, status: { not: 'cancelled' }, event: { endDate: { gte: new Date() } } },
select: { id: true, status: true, event: { select: { id: true, title: true, endDate: true } } },
orderBy: { createdAt: 'asc' },
});
return regs.map(r => ({ registrationId: r.id, status: r.status, eventId: r.event.id, eventTitle: r.event.title, endDate: r.event.endDate }));
}
// ─── Anonymising ──────────────────────────────────────────────────────────────
// Keys in a provider's raw webhook payload that can hold the payer's details (PayFast:
// name_first, name_last, email_address, cell_number; Yoco: customer metadata).
const PERSONAL_KEY = /(^|_)(name|first|last|email|phone|cell|mobile|address|customer|surname)/i;
function scrubPersonal(value) {
if (Array.isArray(value)) return value.map(scrubPersonal);
if (value && typeof value === 'object') {
const out = {};
for (const [k, v] of Object.entries(value)) {
out[k] = PERSONAL_KEY.test(k) && (typeof v === 'string' || typeof v === 'number') ? '[deleted]' : scrubPersonal(v);
}
return out;
}
return value;
}
/**
* Remove a person's personal information while keeping the records the church must keep
* (payments, registrations, tickets, check-ins — amounts and dates) for its accounts and
* historic reports, where they show as "Deleted User". Also covers the attendees on their
* registrations (people they booked for) and their place on other people's bookings.
* Irreversible. Returns counts for the audit log.
*/
async function anonymiseUser(userId, db = prisma) {
const user = await db.user.findUnique({ where: { id: userId }, select: { id: true } });
if (!user) return null;
const { clearTrustedDevices } = require('./twoFactor');
const counts = await db.$transaction(async tx => {
await tx.user.update({
where: { id: userId },
data: {
name: DELETED_NAME,
email: `deleted-${crypto.randomUUID()}@deleted.invalid`,
password: '',
phoneNumber: null,
isActive: false,
twoFactorEnabled: false,
twoFactorMethod: null,
tokenVersion: { increment: 1 },
newsEmail: false,
newsWhatsApp: false,
homeCampusId: null,
},
});
const attendees = await tx.attendee.findMany({ where: { OR: [{ userId }, { registration: { userId } }] }, select: { id: true } });
const attendeeIds = attendees.map(a => a.id);
if (attendeeIds.length) {
await tx.attendee.updateMany({
where: { id: { in: attendeeIds } },
data: { name: DELETED_ATTENDEE_NAME, email: null, phone: null, dateOfBirth: null, gender: null, parentName: null, parentEmail: null, parentPhone: null },
});
await tx.consentRequest.updateMany({
where: { attendeeId: { in: attendeeIds } },
data: { medical: null, emergency: null, parentName: null, parentEmail: null, parentPhone: null, signedName: null, ip: null, device: null, medicalPurgedAt: new Date() },
});
}
// Form answers on their registrations (and for their attendees elsewhere) hold
// whatever the form asked — delete the answers, keep that a form was filled in.
const answers = await tx.formAnswer.deleteMany({
where: { response: { OR: [{ registration: { userId } }, ...(attendeeIds.length ? [{ attendeeId: { in: attendeeIds } }] : [])] } },
});
await tx.formDraft.deleteMany({ where: { userId } });
// Feedback stays (it's about the event) but no longer says who gave it.
await tx.feedbackResponse.updateMany({ where: { userId }, data: { userId: null } });
await tx.feedbackInvite.deleteMany({ where: { userId } });
await tx.waitlistEntry.updateMany({ where: { userId, status: { in: ['waiting', 'offered'] } }, data: { status: 'left', offerTokenHash: null } });
await tx.ticketTransferRequest.deleteMany({ where: { requestedById: userId } });
await tx.ticketTransfer.updateMany({ where: { fromUserId: userId }, data: { fromHolderName: DELETED_NAME } });
await tx.ticketTransfer.updateMany({ where: { toUserId: userId }, data: { toName: DELETED_NAME } });
await tx.certificate.updateMany({ where: { userId }, data: { name: DELETED_NAME } });
await tx.payment.updateMany({ where: { userId }, data: { sponsorName: null, sponsorMessage: null } });
const payments = await tx.payment.findMany({ where: { userId }, select: { id: true } });
const txns = payments.length
? await tx.providerTransaction.findMany({ where: { paymentId: { in: payments.map(p => p.id) }, raw: { not: null } }, select: { id: true, raw: true } })
: [];
for (const t of txns) await tx.providerTransaction.update({ where: { id: t.id }, data: { raw: scrubPersonal(t.raw) } });
const checkouts = await tx.providerCheckout.findMany({ where: { metadata: { path: ['userId'], equals: userId } }, select: { id: true, request: true } });
for (const c of checkouts) await tx.providerCheckout.update({ where: { id: c.id }, data: { request: scrubPersonal(c.request) } });
// Consent and notice records stay as proof, without the IP address they came from.
await tx.communicationConsent.updateMany({ where: { userId }, data: { ip: null } });
await tx.noticeAcceptance.updateMany({ where: { userId }, data: { ip: null } });
await tx.securityEvent.deleteMany({ where: { userId } });
await tx.passwordReset.deleteMany({ where: { userId } });
await tx.twoFactorChallenge.deleteMany({ where: { userId } });
// Kids check-in: leave their family; a family with no parent left is deleted with its
// children (their check-ins stay as attendance, without who collected them).
const { familyDeleted } = await require('./kids').removeFromFamily(tx, userId);
await tx.kidsCheckIn.updateMany({ where: { checkedOutById: userId }, data: { checkedOutById: null } });
// Volunteer rosters: shifts still to come are given up; past ones stay for hours served.
const shiftsGivenUp = await require('./volunteers').forgetVolunteer(tx, userId);
// Event series they followed.
await tx.seriesFollow.deleteMany({ where: { userId } });
// Webhook deliveries about them (kept 30 days for the delivery log).
await tx.webhookDelivery.deleteMany({ where: { userId } });
// Their saved list filters (can hold search text, such as names).
await tx.savedFilter.deleteMany({ where: { userId } });
// AI helper calls (2.0): kept for the site's monthly totals, no longer linked to them.
await tx.aiCall.updateMany({ where: { userId }, data: { userId: null } });
return { attendees: attendeeIds.length, formAnswers: answers.count, providerRecords: txns.length + checkouts.length, familyDeleted, shiftsGivenUp };
});
await clearTrustedDevices(userId);
return counts;
}
// ─── Download my data ─────────────────────────────────────────────────────────
/** Everything held about a person, as plain JSON. */
async function exportUserData(userId, db = prisma) {
const { openJson } = require('./consent');
const user = await db.user.findUnique({
where: { id: userId },
select: {
id: true, name: true, email: true, phoneNumber: true, role: true, createdAt: true, updatedAt: true,
notificationPreference: true, twoFactorEnabled: true, twoFactorMethod: true,
newsEmail: true, newsWhatsApp: true, newsAskedAt: true,
},
});
if (!user) return null;
const [registrations, payments, tickets, waitlist, certificates, feedback, consents, security, requests, notices, family, volunteering, seriesFollowed, seasonPasses] = await Promise.all([
db.registration.findMany({
where: { userId },
orderBy: { createdAt: 'asc' },
include: {
event: { select: { title: true, startDate: true, endDate: true } },
registrationOptions: { include: { eventOption: { select: { name: true } }, variant: { select: { name: true } } } },
attendees: { include: { consentRequests: { orderBy: { createdAt: 'desc' }, take: 1 } } },
formResponses: { include: { answers: { include: { field: { select: { label: true } } } } } },
},
}),
db.payment.findMany({ where: { userId }, orderBy: { createdAt: 'asc' }, include: { event: { select: { title: true } } } }),
db.ticket.findMany({
where: { OR: [{ userId }, { holderUserId: userId }] },
orderBy: { createdAt: 'asc' },
include: { event: { select: { title: true } }, usages: { select: { scannedAt: true, sessionId: true } } },
}),
db.waitlistEntry.findMany({ where: { userId }, include: { event: { select: { title: true } } } }),
db.certificate.findMany({ where: { userId }, include: { event: { select: { title: true } } } }),
db.feedbackResponse.findMany({ where: { userId }, include: { form: { include: { event: { select: { title: true } } } }, answers: { include: { field: { select: { label: true } } } } } }),
consentHistory(userId, db),
db.securityEvent.findMany({ where: { userId }, orderBy: { createdAt: 'desc' }, take: 100, select: { type: true, ip: true, device: true, createdAt: true } }),
db.dataRequest.findMany({ where: { userId }, orderBy: { createdAt: 'desc' }, select: { type: true, status: true, details: true, response: true, createdAt: true, closedAt: true } }),
db.noticeAcceptance.findMany({ where: { userId }, orderBy: { createdAt: 'desc' }, select: { version: true, source: true, createdAt: true } }),
require('./kids').exportFamily(userId, db),
require('./volunteers').exportVolunteering(userId, db),
require('./series').exportFollows(userId, db),
require('./seasonPass').exportPurchases(userId, db),
]);
return {
exportedAt: new Date().toISOString(),
account: user,
communication: {
notificationChannel: user.notificationPreference,
news: { email: user.newsEmail, whatsapp: user.newsWhatsApp, answeredAt: user.newsAskedAt },
history: consents.map(c => ({ channel: c.channel, granted: c.granted, source: c.source, at: c.createdAt })),
},
privacyNoticeAccepted: notices.map(n => ({ version: n.version, how: n.source, at: n.createdAt })),
registrations: registrations.map(r => ({
id: r.id,
event: r.event?.title,
eventStart: r.event?.startDate,
status: r.status,
createdAt: r.createdAt,
options: r.registrationOptions.map(o => ({ option: o.eventOption?.name, variant: o.variant?.name || null, quantity: o.quantity, price: o.priceSnapshot })),
attendees: r.attendees.map(a => {
const consent = a.consentRequests[0];
return {
name: a.name, email: a.email, phone: a.phone, dateOfBirth: a.dateOfBirth, gender: a.gender,
parentName: a.parentName, parentEmail: a.parentEmail, parentPhone: a.parentPhone,
parentalConsent: consent ? {
status: consent.status, signedName: consent.signedName, respondedAt: consent.respondedAt,
photoConsent: consent.photoConsent, medical: openJson(consent.medical), emergency: openJson(consent.emergency),
} : null,
};
}),
formAnswers: r.formResponses.flatMap(f => f.answers.map(a => ({ question: a.field?.label, answer: a.value }))),
})),
payments: payments.map(p => ({
amount: p.amount, method: p.method, provider: p.provider, status: p.status, event: p.event?.title || null,
donation: p.isDonation, sponsorName: p.sponsorName, sponsorMessage: p.sponsorMessage, at: p.createdAt,
})),
tickets: tickets.map(t => ({ event: t.event?.title, quantity: t.quantity, checkIns: t.usages.map(u => u.scannedAt), createdAt: t.createdAt })),
waitlist: waitlist.map(w => ({ event: w.event?.title, quantity: w.quantity, status: w.status, joinedAt: w.createdAt })),
certificates: certificates.map(c => ({ event: c.event?.title, name: c.name, code: c.code, issuedAt: c.issuedAt, revoked: !!c.revokedAt })),
feedback: feedback.map(f => ({ event: f.form?.event?.title, at: f.createdAt, answers: f.answers.map(a => ({ question: a.field?.label, answer: a.value })) })),
accountActivity: security.map(s => ({ type: s.type, ip: s.ip, device: s.device, at: s.createdAt })),
dataRequests: requests,
kidsFamily: family,
volunteering,
seriesFollowed,
seasonPasses,
};
}
/** A readable PDF of the export (the JSON is the complete copy). Resolves to a Buffer. */
async function dataExportPdf(data) {
const PDFDocument = require('pdfkit');
const { getBranding } = require('./pdfDocs');
const org = await getBranding();
const doc = new PDFDocument({ size: 'A4', margin: 48 });
const chunks = [];
doc.on('data', c => chunks.push(c));
const done = new Promise(resolve => doc.on('end', () => resolve(Buffer.concat(chunks))));
const fmt = d => (d ? new Date(d).toLocaleString('en-ZA', { timeZone: 'Africa/Johannesburg' }) : '—');
const heading = text => {
if (doc.y > doc.page.height - 120) doc.addPage();
doc.moveDown(0.8).fillColor(org.brandColor).font('Helvetica-Bold').fontSize(13).text(text).moveDown(0.3).fillColor('#1e293b');
};
const line = (label, value) => doc.font('Helvetica-Bold').fontSize(10).text(`${label}: `, { continued: true }).font('Helvetica').text(value == null || value === '' ? '—' : String(value));
const para = text => doc.font('Helvetica').fontSize(10).text(text);
doc.fillColor(org.brandColor).font('Helvetica-Bold').fontSize(20).text('Your personal information');
doc.fillColor('#64748b').font('Helvetica').fontSize(10).text(`${org.name} · exported ${fmt(data.exportedAt)}`);
doc.moveDown(0.4).text('This is a readable summary. The JSON file you can download alongside it is the complete copy.');
doc.fillColor('#1e293b');
const a = data.account;
heading('Account');
line('Name', a.name); line('Email', a.email); line('Phone', a.phoneNumber); line('Role', a.role);
line('Created', fmt(a.createdAt)); line('Two-factor', a.twoFactorEnabled ? `on (${a.twoFactorMethod})` : 'off');
heading('Communication');
line('Notifications by', a.notificationPreference);
line('News by email', data.communication.news.email ? 'yes' : 'no');
line('News by WhatsApp', data.communication.news.whatsapp ? 'yes' : 'no');
for (const h of data.communication.history) para(`${fmt(h.at)} — ${h.channel} news ${h.granted ? 'on' : 'off'} (${h.source.replace(/_/g, ' ')})`);
heading(`Registrations (${data.registrations.length})`);
for (const r of data.registrations) {
doc.font('Helvetica-Bold').fontSize(10).text(`${r.event} — ${r.status}`).font('Helvetica');
para(`Registered ${fmt(r.createdAt)}; ${r.options.map(o => `${o.quantity} × ${o.option}${o.variant ? ` (${o.variant})` : ''}`).join(', ')}`);
for (const p of r.attendees) para(`Attendee: ${p.name}${p.dateOfBirth ? `, born ${new Date(p.dateOfBirth).toLocaleDateString('en-ZA')}` : ''}${p.parentalConsent ? `, parental consent ${p.parentalConsent.status}` : ''}`);
for (const f of r.formAnswers) para(`${f.question}: ${f.answer}`);
doc.moveDown(0.3);
}
heading(`Payments (${data.payments.length})`);
for (const p of data.payments) para(`${fmt(p.at)} — R${Number(p.amount).toFixed(2)} ${p.method}${p.event ? `, ${p.event}` : ''}${p.donation ? ' (donation)' : ''}`);
heading(`Tickets (${data.tickets.length})`);
for (const t of data.tickets) para(`${t.event} — ${t.quantity} place${t.quantity === 1 ? '' : 's'}, ${t.checkIns.length} check-in${t.checkIns.length === 1 ? '' : 's'}`);
if (data.certificates.length) {
heading('Certificates');
for (const c of data.certificates) para(`${c.event} — ${c.code}${c.revoked ? ' (withdrawn)' : ''}`);
}
if (data.volunteering?.length) {
heading('Serving (volunteer rosters)');
for (const s of data.volunteering) para(`${fmt(s.from)} — ${s.role}, ${s.event}${s.checkedIn ? ' (checked in)' : ''}`);
}
if (data.seasonPasses?.length) {
heading('Season passes');
for (const s of data.seasonPasses) para(`${fmt(s.at)} — ${s.quantity} × ${s.pass}, R${Number(s.total).toFixed(2)} (${s.status})`);
}
if (data.seriesFollowed?.length) {
heading('Event series you follow');
for (const f of data.seriesFollowed) para(`${f.series} — since ${fmt(f.since)}`);
}
if (data.feedback.length) {
heading('Feedback you gave');
for (const f of data.feedback) {
doc.font('Helvetica-Bold').fontSize(10).text(f.event || 'Event').font('Helvetica');
for (const ans of f.answers) para(`${ans.question}: ${ans.answer}`);
}
}
heading('Recent account activity');
for (const s of data.accountActivity.slice(0, 20)) para(`${fmt(s.at)} — ${s.type.replace(/_/g, ' ')}${s.device ? `, ${s.device}` : ''}`);
doc.end();
return done;
}
module.exports = {
CHANNELS,
MESSAGE_KINDS,
REQUEST_DUE_DAYS,
DELETED_NAME,
normaliseKind,
setNewsPreferences,
consentHistory,
unsubscribeToken,
readUnsubscribeToken,
unsubscribePageUrl,
describeUnsubscribe,
unsubscribe,
optOutAddress,
filterRecipients,
bulkEmailFooter,
whatsAppNewsFooter,
isStopKeyword,
whatsAppStop,
createDataRequest,
privacyContacts,
remindDueRequests,
deletionBlockers,
scrubPersonal,
anonymiseUser,
exportUserData,
dataExportPdf,
};