POPIA toolkit part 2: privacy notice editor, operators, consent and access logs
- Admin -> Privacy (POPIA): edit the privacy notice (built-in text as the
start, placeholders for org/IO/operators), drafts, preview, numbered
versions; earlier versions readable on /legal/privacy?version=N
- "Significant change" versions are accepted once after login
(NoticePrompt); sign-up records the version accepted
- Operator register (seeded with the services the app uses), listed in
the notice via {operators}
- Consent log (news opt-ins, notice acceptances, parental consent) and
access log (report exports, registers, certificates, group lists, form
answers, consent/medical lists, backups, impersonation)
- Information Officer on the contact page
- Unit tests (privacyNotice.test.js), e2e (privacy-notice.spec.ts); docs
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012mt6TCv85T9VKRq3cV7rXq
This commit is contained in:
@@ -287,6 +287,10 @@ const getSetLists = async (req, res) => {
|
||||
if (!set) throw allocationError('Allocation set not found', 404);
|
||||
const withMedical = req.query.medical === 'true';
|
||||
const members = await groupMembers(set.groups.map(g => g.id), { withMedical });
|
||||
require('../utils/accessLog').logDataAccess(req, {
|
||||
action: withMedical ? 'medical_list' : 'group_lists', what: `${set.name} lists — ${set.event?.title || 'event'}${withMedical ? ' (with medical details)' : ''}`,
|
||||
eventId: set.eventId, records: members.length,
|
||||
});
|
||||
if (withMedical) {
|
||||
logAdminAction({ actorId: req.user.id, actorRole: req.user.role, action: 'medical_list_viewed', targetType: 'AllocationSet', targetId: set.id, metadata: { eventId: set.eventId, attendees: members.length }, ip: getClientIp(req) });
|
||||
}
|
||||
|
||||
@@ -175,6 +175,10 @@ const exportRegister = async (req, res) => {
|
||||
try {
|
||||
const reg = await buildRegister(req.params.eventId);
|
||||
const cols = reg.columns.filter(c => !c.cancelled);
|
||||
require('../utils/accessLog').logDataAccess(req, {
|
||||
action: 'attendance_export', what: `Attendance register — ${reg.event.title} (${req.query.format === 'pdf' ? 'PDF' : 'Excel'})`,
|
||||
eventId: req.params.eventId, records: reg.rows.length,
|
||||
});
|
||||
if (req.query.format === 'pdf') {
|
||||
const doc = new PDFDocument({ size: 'A4', layout: 'landscape', margin: 36 });
|
||||
res.setHeader('Content-Type', 'application/pdf');
|
||||
@@ -320,6 +324,7 @@ const downloadEventCertificates = async (req, res) => {
|
||||
const certs = await prisma.certificate.findMany({ where: { eventId: event.id, revokedAt: null }, orderBy: { name: 'asc' } });
|
||||
if (certs.length === 0) throw badRequest('No certificates have been issued for this event yet.');
|
||||
const pdf = await certificates.renderCertificatesPdf(certs, event);
|
||||
require('../utils/accessLog').logDataAccess(req, { action: 'certificates_download', what: `Certificates — ${event.title}`, eventId: event.id, records: certs.length });
|
||||
res.setHeader('Content-Type', 'application/pdf');
|
||||
res.setHeader('Content-Disposition', `attachment; filename="${`Certificates - ${event.title}`.replace(/[^a-z0-9 -]/gi, '').slice(0, 80)}.pdf"`);
|
||||
res.send(pdf);
|
||||
|
||||
@@ -44,6 +44,7 @@ const downloadBackup = async (req, res) => {
|
||||
res.status(404);
|
||||
throw new Error('Backup not found');
|
||||
}
|
||||
require('../utils/accessLog').logDataAccess(req, { action: 'backup_download', what: `Database backup ${filename}` });
|
||||
res.download(filePath, filename);
|
||||
} catch (e) {
|
||||
res.status(res.statusCode === 200 ? 400 : res.statusCode).json({ message: safeErrorMessage(e) });
|
||||
|
||||
@@ -156,6 +156,7 @@ const listEventConsent = async (req, res) => {
|
||||
const { event, rows } = await consentRows(req.params.eventId);
|
||||
if (!event) { res.status(404); throw new Error('Event not found'); }
|
||||
const counts = rows.reduce((c, r) => { c[r.status] = (c[r.status] || 0) + 1; return c; }, {});
|
||||
require('../utils/accessLog').logDataAccess(req, { action: 'consent_list', what: `Parental consent — ${event.title}`, eventId: event.id, records: rows.length });
|
||||
res.json({
|
||||
event: { id: event.id, title: event.title, startDate: event.startDate, requiresParentalConsent: event.requiresParentalConsent, consentTextVersion: event.consentTextVersion },
|
||||
counts,
|
||||
@@ -255,6 +256,7 @@ const medicalList = async (req, res) => {
|
||||
targetType: 'Event', targetId: event.id, metadata: { attendees: list.length },
|
||||
ip: getClientIp(req),
|
||||
});
|
||||
require('../utils/accessLog').logDataAccess(req, { action: 'medical_list', what: `Medical list — ${event.title}`, eventId: event.id, records: list.length });
|
||||
res.json({ event: { id: event.id, title: event.title, startDate: event.startDate }, rows: list });
|
||||
} catch (error) {
|
||||
fail(res, error);
|
||||
|
||||
@@ -43,6 +43,17 @@ const listFormResponses = async (req, res) => {
|
||||
|
||||
const nextCursor = responses.length === take ? responses[responses.length - 1].id : null;
|
||||
|
||||
// The first page of a list (not one registration's own form, nor the next pages of the
|
||||
// same list) is logged as a bulk view of form answers.
|
||||
if (!registrationId && !cursor && responses.length) {
|
||||
require('../utils/accessLog').logDataAccess(req, {
|
||||
action: 'form_responses',
|
||||
what: `Attendee form answers${responses[0].registration?.event && eventId ? ` — ${responses[0].registration.event.title}` : ''}`,
|
||||
eventId: eventId ? String(eventId) : null,
|
||||
records: responses.length,
|
||||
});
|
||||
}
|
||||
|
||||
res.json({ items: responses, nextCursor });
|
||||
} catch (error) {
|
||||
res.status(400).json({ message: error.message });
|
||||
|
||||
@@ -30,6 +30,7 @@ const startImpersonation = async (req, res) => {
|
||||
actorId: req.user.id, actorRole: req.user.role, action: 'impersonation_started', targetType: 'User', targetId: target.id,
|
||||
metadata: { sessionId: session.id, reason: session.reason, targetName: target.name, expiresAt }, ip: getClientIp(req),
|
||||
});
|
||||
require('../utils/accessLog').logDataAccess(req, { action: 'impersonation', what: `Viewed as ${target.name} — ${session.reason}` });
|
||||
|
||||
// Optional: tell the user (Site Settings → Security).
|
||||
const { getSettingSync } = require('../utils/settingsCache');
|
||||
|
||||
@@ -0,0 +1,299 @@
|
||||
const prisma = require('../config/db');
|
||||
const { safeErrorMessage } = require('../utils/errorUtils');
|
||||
const { getClientIp } = require('../utils/requestUtils');
|
||||
const { logAdminAction } = require('../utils/adminAudit');
|
||||
const { ACCESS_ACTIONS } = require('../utils/accessLog');
|
||||
const notice = require('../utils/privacyNotice');
|
||||
|
||||
const fail = (res, error) => res.status(res.statusCode === 200 ? 400 : res.statusCode).json({ message: safeErrorMessage(error) });
|
||||
|
||||
const PAGE_SIZE = 50;
|
||||
const page = req => Math.max(parseInt(req.query.page, 10) || 1, 1);
|
||||
|
||||
// ─── Privacy notice ───────────────────────────────────────────────────────────
|
||||
|
||||
// @desc The privacy notice as published (current, or ?version=N), placeholders filled in
|
||||
// @route GET /api/privacy/notice
|
||||
// @access Public
|
||||
const getNotice = async (req, res) => {
|
||||
try {
|
||||
const version = req.query.version != null ? parseInt(req.query.version, 10) : null;
|
||||
if (req.query.version != null && !(version >= 0)) { res.status(400); throw new Error('Invalid version'); }
|
||||
const result = await notice.publicNotice(version);
|
||||
if (!result) { res.status(404); throw new Error('That version of the privacy notice does not exist.'); }
|
||||
res.json(result);
|
||||
} catch (error) {
|
||||
fail(res, error);
|
||||
}
|
||||
};
|
||||
|
||||
// @desc Accept the current privacy notice
|
||||
// @route POST /api/privacy/me/notice/accept
|
||||
// @access Private
|
||||
const acceptMyNotice = async (req, res) => {
|
||||
try {
|
||||
if (req.impersonation) { res.status(403); throw new Error('Not available while viewing as another user.'); }
|
||||
const version = await notice.acceptNotice(req.user.id, { source: 'prompt', ip: getClientIp(req) });
|
||||
res.json({ version });
|
||||
} catch (error) {
|
||||
fail(res, error);
|
||||
}
|
||||
};
|
||||
|
||||
async function versionList() {
|
||||
const [versions, counts] = await Promise.all([
|
||||
prisma.privacyNotice.findMany({
|
||||
orderBy: { version: 'desc' },
|
||||
select: { version: true, publishedAt: true, changeSummary: true, requiresAcceptance: true, publishedBy: { select: { name: true } } },
|
||||
}),
|
||||
prisma.noticeAcceptance.groupBy({ by: ['version'], _count: { _all: true } }),
|
||||
]);
|
||||
const byVersion = new Map(counts.map(c => [c.version, c._count._all]));
|
||||
return versions.map(v => ({ ...v, publishedBy: v.publishedBy?.name || null, acceptances: byVersion.get(v.version) || 0 }));
|
||||
}
|
||||
|
||||
// @desc The editor: the draft (or current text), how it reads, and the published versions
|
||||
// @route GET /api/privacy/notice/draft
|
||||
// @access Private/Admin
|
||||
const getNoticeDraft = async (req, res) => {
|
||||
try {
|
||||
const draft = await notice.getDraft();
|
||||
const ctx = await notice.noticeContext();
|
||||
res.json({
|
||||
...draft,
|
||||
rendered: notice.renderSections(draft.sections, ctx),
|
||||
placeholders: notice.PLACEHOLDERS,
|
||||
versions: await versionList(),
|
||||
builtIn: notice.defaultSections(),
|
||||
});
|
||||
} catch (error) {
|
||||
fail(res, error);
|
||||
}
|
||||
};
|
||||
|
||||
// @desc Save the draft (body.sections)
|
||||
// @route PUT /api/privacy/notice/draft
|
||||
// @access Private/Admin
|
||||
const saveNoticeDraft = async (req, res) => {
|
||||
try {
|
||||
const sections = await notice.saveDraft(req.body?.sections);
|
||||
res.json({ sections, rendered: notice.renderSections(sections, await notice.noticeContext()), isDraft: true, savedAt: new Date() });
|
||||
} catch (error) {
|
||||
fail(res, error);
|
||||
}
|
||||
};
|
||||
|
||||
// @desc Throw the draft away (back to the current published text)
|
||||
// @route DELETE /api/privacy/notice/draft
|
||||
// @access Private/Admin
|
||||
const discardNoticeDraft = async (req, res) => {
|
||||
try {
|
||||
await notice.discardDraft();
|
||||
res.json({ message: 'Draft discarded.' });
|
||||
} catch (error) {
|
||||
fail(res, error);
|
||||
}
|
||||
};
|
||||
|
||||
// @desc Publish body.sections as the next version (body.changeSummary, body.requiresAcceptance)
|
||||
// @route POST /api/privacy/notice/publish
|
||||
// @access Private/Admin
|
||||
const publishNotice = async (req, res) => {
|
||||
try {
|
||||
const { sections, changeSummary, requiresAcceptance } = req.body || {};
|
||||
if (requiresAcceptance && !String(changeSummary || '').trim()) {
|
||||
res.status(400);
|
||||
throw new Error('Say what changed — people see it when they are asked to accept the new version.');
|
||||
}
|
||||
const published = await notice.publish({ sections, changeSummary, requiresAcceptance, publishedById: req.user.id });
|
||||
logAdminAction({
|
||||
actorId: req.user.id, actorRole: req.user.role, action: 'privacy_notice_published', targetType: 'privacy_notice', targetId: published.id,
|
||||
metadata: { version: published.version, requiresAcceptance: published.requiresAcceptance, changeSummary: published.changeSummary }, ip: getClientIp(req),
|
||||
});
|
||||
res.status(201).json({ version: published.version, publishedAt: published.publishedAt, requiresAcceptance: published.requiresAcceptance });
|
||||
} catch (error) {
|
||||
fail(res, error);
|
||||
}
|
||||
};
|
||||
|
||||
// ─── Operators ────────────────────────────────────────────────────────────────
|
||||
|
||||
const OPERATOR_FIELDS = ['name', 'purpose', 'dataShared', 'location', 'website'];
|
||||
|
||||
function operatorData(body, { partial = false } = {}) {
|
||||
const data = {};
|
||||
for (const f of OPERATOR_FIELDS) {
|
||||
if (body?.[f] === undefined) continue;
|
||||
const v = body[f] == null ? '' : String(body[f]).trim().slice(0, f === 'name' ? 200 : 1000);
|
||||
data[f] = v || (f === 'location' || f === 'website' ? null : '');
|
||||
}
|
||||
if (typeof body?.active === 'boolean') data.active = body.active;
|
||||
if (Number.isInteger(body?.order)) data.order = body.order;
|
||||
if ((!partial || 'name' in data) && !data.name) throw new Error('Give the operator a name.');
|
||||
if ((!partial || 'purpose' in data) && !data.purpose) throw new Error('Say what the operator does for you.');
|
||||
if (data.website && !/^https?:\/\//i.test(data.website)) data.website = `https://${data.website}`;
|
||||
return data;
|
||||
}
|
||||
|
||||
// @desc The operator register
|
||||
// @route GET /api/privacy/operators
|
||||
// @access Private/Admin
|
||||
const listOperators = async (req, res) => {
|
||||
try {
|
||||
res.json(await prisma.operator.findMany({ orderBy: [{ order: 'asc' }, { name: 'asc' }] }));
|
||||
} catch (error) {
|
||||
fail(res, error);
|
||||
}
|
||||
};
|
||||
|
||||
// @route POST /api/privacy/operators
|
||||
const createOperator = async (req, res) => {
|
||||
try {
|
||||
const data = operatorData(req.body);
|
||||
if (data.order === undefined) data.order = (await prisma.operator.count()) + 1;
|
||||
const op = await prisma.operator.create({ data });
|
||||
logAdminAction({ actorId: req.user.id, actorRole: req.user.role, action: 'operator_created', targetType: 'operator', targetId: op.id, metadata: { name: op.name }, ip: getClientIp(req) });
|
||||
res.status(201).json(op);
|
||||
} catch (error) {
|
||||
fail(res, error);
|
||||
}
|
||||
};
|
||||
|
||||
// @route PUT /api/privacy/operators/:id
|
||||
const updateOperator = async (req, res) => {
|
||||
try {
|
||||
const existing = await prisma.operator.findUnique({ where: { id: req.params.id } });
|
||||
if (!existing) { res.status(404); throw new Error('Operator not found'); }
|
||||
const op = await prisma.operator.update({ where: { id: existing.id }, data: operatorData(req.body, { partial: true }) });
|
||||
logAdminAction({ actorId: req.user.id, actorRole: req.user.role, action: 'operator_updated', targetType: 'operator', targetId: op.id, metadata: { name: op.name, active: op.active }, ip: getClientIp(req) });
|
||||
res.json(op);
|
||||
} catch (error) {
|
||||
fail(res, error);
|
||||
}
|
||||
};
|
||||
|
||||
// @route DELETE /api/privacy/operators/:id
|
||||
const deleteOperator = async (req, res) => {
|
||||
try {
|
||||
const existing = await prisma.operator.findUnique({ where: { id: req.params.id } });
|
||||
if (!existing) { res.status(404); throw new Error('Operator not found'); }
|
||||
await prisma.operator.delete({ where: { id: existing.id } });
|
||||
logAdminAction({ actorId: req.user.id, actorRole: req.user.role, action: 'operator_deleted', targetType: 'operator', targetId: existing.id, metadata: { name: existing.name }, ip: getClientIp(req) });
|
||||
res.json({ message: 'Operator removed.' });
|
||||
} catch (error) {
|
||||
fail(res, error);
|
||||
}
|
||||
};
|
||||
|
||||
// ─── Consent log ──────────────────────────────────────────────────────────────
|
||||
|
||||
// Filter on the person's name or email.
|
||||
function personWhere(q) {
|
||||
return q ? { OR: [{ name: { contains: q, mode: 'insensitive' } }, { email: { contains: q, mode: 'insensitive' } }] } : undefined;
|
||||
}
|
||||
|
||||
// @desc Proof of consent: ?type=news (news opt-in changes), notice (privacy notice
|
||||
// acceptances) or parental (parental consent answers); ?q= name/email; ?page=
|
||||
// @route GET /api/privacy/consent-log
|
||||
// @access Private/Admin
|
||||
const consentLog = async (req, res) => {
|
||||
try {
|
||||
const type = String(req.query.type || 'news');
|
||||
const q = String(req.query.q || '').trim();
|
||||
const skip = (page(req) - 1) * PAGE_SIZE;
|
||||
const user = { select: { name: true, email: true } };
|
||||
|
||||
if (type === 'news') {
|
||||
const where = q ? { OR: [{ user: personWhere(q) }, { address: { contains: q, mode: 'insensitive' } }] } : {};
|
||||
const [rows, total] = await Promise.all([
|
||||
prisma.communicationConsent.findMany({ where, orderBy: { createdAt: 'desc' }, skip, take: PAGE_SIZE, include: { user } }),
|
||||
prisma.communicationConsent.count({ where }),
|
||||
]);
|
||||
return res.json({
|
||||
total, pageSize: PAGE_SIZE,
|
||||
rows: rows.map(r => ({ id: r.id, at: r.createdAt, name: r.user?.name || null, email: r.user?.email || r.address, channel: r.channel, granted: r.granted, source: r.source, ip: r.ip })),
|
||||
});
|
||||
}
|
||||
if (type === 'notice') {
|
||||
const where = q ? { user: personWhere(q) } : {};
|
||||
const [rows, total] = await Promise.all([
|
||||
prisma.noticeAcceptance.findMany({ where, orderBy: { createdAt: 'desc' }, skip, take: PAGE_SIZE, include: { user } }),
|
||||
prisma.noticeAcceptance.count({ where }),
|
||||
]);
|
||||
return res.json({
|
||||
total, pageSize: PAGE_SIZE,
|
||||
rows: rows.map(r => ({ id: r.id, at: r.createdAt, name: r.user?.name || null, email: r.user?.email || null, version: r.version, source: r.source, ip: r.ip })),
|
||||
});
|
||||
}
|
||||
if (type === 'parental') {
|
||||
const where = {
|
||||
status: { in: ['given', 'declined'] },
|
||||
...(q ? { OR: [{ attendee: { name: { contains: q, mode: 'insensitive' } } }, { parentName: { contains: q, mode: 'insensitive' } }, { parentEmail: { contains: q, mode: 'insensitive' } }, { signedName: { contains: q, mode: 'insensitive' } }] } : {}),
|
||||
};
|
||||
const [rows, total] = await Promise.all([
|
||||
prisma.consentRequest.findMany({
|
||||
where, orderBy: { respondedAt: 'desc' }, skip, take: PAGE_SIZE,
|
||||
select: { id: true, status: true, signedName: true, parentName: true, textVersion: true, photoConsent: true, respondedAt: true, ip: true, medicalPurgedAt: true, attendee: { select: { name: true } }, event: { select: { title: true } } },
|
||||
}),
|
||||
prisma.consentRequest.count({ where }),
|
||||
]);
|
||||
return res.json({
|
||||
total, pageSize: PAGE_SIZE,
|
||||
rows: rows.map(r => ({
|
||||
id: r.id, at: r.respondedAt, child: r.attendee?.name, event: r.event?.title, status: r.status, signedName: r.signedName,
|
||||
parentName: r.parentName, textVersion: r.textVersion, photoConsent: r.photoConsent, ip: r.ip, medicalDeleted: !!r.medicalPurgedAt,
|
||||
})),
|
||||
});
|
||||
}
|
||||
res.status(400);
|
||||
throw new Error('type must be news, notice or parental');
|
||||
} catch (error) {
|
||||
fail(res, error);
|
||||
}
|
||||
};
|
||||
|
||||
// ─── Access log ───────────────────────────────────────────────────────────────
|
||||
|
||||
// @desc Who exported or viewed personal information in bulk (?action=, ?actorId=, ?from=, ?to=, ?page=)
|
||||
// @route GET /api/privacy/access-log
|
||||
// @access Private/Admin
|
||||
const accessLog = async (req, res) => {
|
||||
try {
|
||||
const where = {};
|
||||
if (req.query.action) where.action = String(req.query.action);
|
||||
if (req.query.actorId) where.actorId = String(req.query.actorId);
|
||||
if (req.query.from || req.query.to) {
|
||||
where.createdAt = {};
|
||||
if (req.query.from) where.createdAt.gte = new Date(String(req.query.from));
|
||||
if (req.query.to) where.createdAt.lte = new Date(String(req.query.to));
|
||||
}
|
||||
const [rows, total, actors] = await Promise.all([
|
||||
prisma.dataAccessLog.findMany({ where, orderBy: { createdAt: 'desc' }, skip: (page(req) - 1) * PAGE_SIZE, take: PAGE_SIZE, include: { actor: { select: { name: true } } } }),
|
||||
prisma.dataAccessLog.count({ where }),
|
||||
prisma.dataAccessLog.findMany({ where: { actorId: { not: null } }, distinct: ['actorId'], select: { actorId: true, actor: { select: { name: true } } } }),
|
||||
]);
|
||||
res.json({
|
||||
total, pageSize: PAGE_SIZE,
|
||||
actions: ACCESS_ACTIONS,
|
||||
actors: actors.map(a => ({ id: a.actorId, name: a.actor?.name || 'Unknown' })),
|
||||
rows: rows.map(r => ({ id: r.id, at: r.createdAt, actor: r.actor?.name || 'Deleted user', actorRole: r.actorRole, action: r.action, what: r.what, records: r.records, eventId: r.eventId, ip: r.ip })),
|
||||
});
|
||||
} catch (error) {
|
||||
fail(res, error);
|
||||
}
|
||||
};
|
||||
|
||||
module.exports = {
|
||||
getNotice,
|
||||
acceptMyNotice,
|
||||
getNoticeDraft,
|
||||
saveNoticeDraft,
|
||||
discardNoticeDraft,
|
||||
publishNotice,
|
||||
listOperators,
|
||||
createOperator,
|
||||
updateOperator,
|
||||
deleteOperator,
|
||||
consentLog,
|
||||
accessLog,
|
||||
};
|
||||
@@ -397,6 +397,13 @@ function writeTableRows(ws, startRow, columns, rows) {
|
||||
return { nextRow: r, dataStartRow };
|
||||
}
|
||||
|
||||
// POPIA access log: who took which report out of the system, and how many rows.
|
||||
function logReport(req, action) {
|
||||
const { logDataAccess, reportRowCount } = require('../utils/accessLog');
|
||||
const p = req.body || {};
|
||||
logDataAccess(req, { action, what: [p.title || 'Report', p.subtitle].filter(Boolean).join(' — '), records: reportRowCount(p) });
|
||||
}
|
||||
|
||||
// POST /api/reports/pdf
|
||||
// body: { title, subtitle?, kind: 'table'|'layered', table?, layered?, stats?, chart?, note?, orientation? }
|
||||
const generatePdf = async (req, res) => {
|
||||
@@ -410,6 +417,7 @@ const generatePdf = async (req, res) => {
|
||||
doc.pipe(res);
|
||||
drawReportPdf(doc, { title, subtitle, kind, table, layered, stats, chart, note, extraTables });
|
||||
doc.end();
|
||||
logReport(req, 'report_pdf');
|
||||
} catch (e) {
|
||||
res.status(400).json({ message: e.message });
|
||||
}
|
||||
@@ -426,6 +434,7 @@ const generateExcel = async (req, res) => {
|
||||
res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
|
||||
await wb.xlsx.write(res);
|
||||
res.end();
|
||||
logReport(req, 'report_excel');
|
||||
} catch (e) {
|
||||
res.status(400).json({ message: e.message });
|
||||
}
|
||||
@@ -462,6 +471,7 @@ const emailPdf = async (req, res) => {
|
||||
|
||||
try { fs.unlinkSync(filePath); } catch {}
|
||||
|
||||
logReport(req, 'report_email');
|
||||
res.json({ message: `Report emailed to ${user.email}` });
|
||||
} catch (e) {
|
||||
res.status(400).json({ message: e.message });
|
||||
@@ -489,6 +499,7 @@ const whatsappPdf = async (req, res) => {
|
||||
const filename = `${(title || 'report').replace(/[^a-z0-9]/gi, '_').toLowerCase()}.pdf`;
|
||||
await sendPdf(user.phoneNumber, filePath, filename, caption || title || 'Report');
|
||||
|
||||
logReport(req, 'report_whatsapp');
|
||||
res.json({ message: `Report sent to your WhatsApp` });
|
||||
} catch (e) {
|
||||
res.status(400).json({ message: e.message });
|
||||
|
||||
@@ -140,6 +140,7 @@ async function sendWelcomeEmail(user) {
|
||||
const LOGIN_USER_SELECT = {
|
||||
id: true, name: true, email: true, role: true, tokenVersion: true, isActive: true,
|
||||
phoneNumber: true, notificationPreference: true, twoFactorEnabled: true, twoFactorMethod: true, newsAskedAt: true,
|
||||
noticeVersionAccepted: true,
|
||||
};
|
||||
|
||||
// Errors from utils/twoFactor carry their own HTTP status; everything else follows
|
||||
@@ -150,7 +151,9 @@ function errorStatus(error, res) {
|
||||
|
||||
// Final step of a successful login (after the password, and the 2FA code when
|
||||
// required): notify, record the activity, and issue the session token.
|
||||
function completeLogin(user, req, res, extra = {}) {
|
||||
async function completeLogin(user, req, res, extra = {}) {
|
||||
const noticePromptPending = await require('../utils/privacyNotice').noticePromptPending(user).catch(() => false);
|
||||
|
||||
// Send login notification in the background
|
||||
sendLoginNotification(user, req).catch(() => {});
|
||||
logSecurityEvent({ userId: user.id, type: 'login', ip: getClientIp(req), userAgent: req.headers['user-agent'] }).catch(() => {});
|
||||
@@ -161,8 +164,10 @@ function completeLogin(user, req, res, extra = {}) {
|
||||
email: user.email,
|
||||
role: user.role,
|
||||
token: generateToken(user.id, user.role, user.tokenVersion),
|
||||
// POPIA: ask about News & announcements once (see NewsPrompt on the frontend).
|
||||
// POPIA: ask about News & announcements once (see NewsPrompt on the frontend), and to
|
||||
// accept a privacy notice version marked as a significant change (NoticePrompt).
|
||||
newsPromptPending: !user.newsAskedAt,
|
||||
noticePromptPending,
|
||||
...extra
|
||||
});
|
||||
}
|
||||
@@ -224,6 +229,9 @@ const registerUser = async (req, res) => {
|
||||
{ email: newsOptIn === true, whatsapp: newsOptIn === true },
|
||||
{ source: 'signup', ip: getClientIp(req), answered: true, logAll: true },
|
||||
).catch(e => console.warn('[signup] news preference not saved:', e?.message || e));
|
||||
// The sign-up form requires ticking "I agree to the Terms of Use and Privacy Policy".
|
||||
await require('../utils/privacyNotice').acceptNotice(user.id, { source: 'signup', ip: getClientIp(req) })
|
||||
.catch(e => console.warn('[signup] notice acceptance not saved:', e?.message || e));
|
||||
|
||||
|
||||
// Send welcome email in the background — don't block the response
|
||||
@@ -351,7 +359,7 @@ const loginUser = async (req, res) => {
|
||||
}
|
||||
}
|
||||
|
||||
completeLogin(updated, req, res);
|
||||
await completeLogin(updated, req, res);
|
||||
} catch (error) {
|
||||
res.status(errorStatus(error, res)).json({ message: safeErrorMessage(error) });
|
||||
}
|
||||
@@ -386,7 +394,7 @@ const verifyLoginTwoFactor = async (req, res) => {
|
||||
if (rememberDevice === true) {
|
||||
extra.deviceToken = await issueTrustedDevice(user.id, req.headers['user-agent']);
|
||||
}
|
||||
completeLogin(user, req, res, extra);
|
||||
await completeLogin(user, req, res, extra);
|
||||
} catch (error) {
|
||||
res.status(errorStatus(error, res)).json({ message: safeErrorMessage(error) });
|
||||
}
|
||||
@@ -527,14 +535,17 @@ const getUserProfile = async (req, res) => {
|
||||
createdAt: true,
|
||||
updatedAt: true,
|
||||
isActive: true,
|
||||
newsAskedAt: true
|
||||
newsAskedAt: true,
|
||||
noticeVersionAccepted: true
|
||||
}
|
||||
});
|
||||
|
||||
if (user) {
|
||||
const { newsAskedAt, ...rest } = user;
|
||||
const { newsAskedAt, noticeVersionAccepted, ...rest } = user;
|
||||
// newsPromptPending: they haven't answered the news opt-in question yet (asked once).
|
||||
res.json({ ...rest, twoFactorRequired: requiresTwoFactor(user), newsPromptPending: !newsAskedAt && !req.impersonation });
|
||||
// noticePromptPending: a privacy notice version they must accept has been published.
|
||||
const noticePromptPending = !req.impersonation && await require('../utils/privacyNotice').noticePromptPending({ noticeVersionAccepted });
|
||||
res.json({ ...rest, twoFactorRequired: requiresTwoFactor(user), newsPromptPending: !newsAskedAt && !req.impersonation, noticePromptPending });
|
||||
} else {
|
||||
res.status(404);
|
||||
throw new Error('User not found');
|
||||
|
||||
Reference in New Issue
Block a user