650 lines
31 KiB
JavaScript
650 lines
31 KiB
JavaScript
/**
|
||
* 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/privacy/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, '&').replace(/</g, '<').replace(/>/g, '>').replace(/"/g, '"');
|
||
}
|
||
|
||
/**
|
||
* 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 ? ` · <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 } });
|
||
|
||
return { attendees: attendeeIds.length, formAnswers: answers.count, providerRecords: txns.length + checkouts.length, familyDeleted };
|
||
});
|
||
|
||
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] = 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),
|
||
]);
|
||
|
||
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,
|
||
};
|
||
}
|
||
|
||
/** 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.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,
|
||
};
|