WIP 1.51.8: event detail, options, variants, attachments, calendar and alias on v2
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Ls1vMdg2GYqbnKZmPaX1ot
This commit is contained in:
@@ -1,20 +1,18 @@
|
||||
const prisma = require('../config/db');
|
||||
const { v4: uuidv4 } = require('uuid');
|
||||
const multer = require('multer');
|
||||
const path = require('path');
|
||||
const fs = require('fs');
|
||||
const crypto = require('crypto');
|
||||
const { assertEventOpen } = require('../utils/cashupUtils');
|
||||
const { getClientIp } = require('../utils/requestUtils');
|
||||
const sessionsUtil = require('../utils/sessions');
|
||||
const { publicOptions } = require('../utils/volunteers');
|
||||
const { campusesEnabled, campusWhere, resolveCampusFilter, EVENT_CAMPUS_SELECT } = require('../utils/campuses');
|
||||
const { scopeFor, canView } = require('../utils/campusScope');
|
||||
const seriesUtil = require('../utils/series');
|
||||
const { scopeFor } = require('../utils/campusScope');
|
||||
|
||||
// Setting events up is shared with /api/v2/events (TypeScript, 1.51.7).
|
||||
const eventService = require('../services/events');
|
||||
const { SERIES_SELECT, SESSIONS_INCLUDE, withSchedule } = eventService;
|
||||
const details = require('../services/eventDetails');
|
||||
|
||||
// @desc Copy allocation groups (and, for admins, planned costs) from another event into a new copy
|
||||
// @route POST /api/events/:id/copy-from
|
||||
@@ -222,173 +220,9 @@ const getEventsAll = async (req, res) => {
|
||||
// @access Public
|
||||
const getEventById = async (req, res) => {
|
||||
try {
|
||||
const eventId = req.params.id;
|
||||
// Determine if Prisma Client supports EarlyBirdTier / OptionVariant
|
||||
const canIncludeTiers = !!(prisma && prisma.earlyBirdTier && typeof prisma.earlyBirdTier.findMany === 'function');
|
||||
const canIncludeVariants = !!(prisma && prisma.optionVariant && typeof prisma.optionVariant.findMany === 'function');
|
||||
const optionInclude = canIncludeTiers
|
||||
? { earlyBirdTiers: true, ...(canIncludeVariants ? { variants: { orderBy: { order: 'asc' } } } : {}) }
|
||||
: undefined;
|
||||
const includeObj = { eventOptions: optionInclude ? { include: optionInclude } : true, sessions: SESSIONS_INCLUDE, campus: { select: EVENT_CAMPUS_SELECT }, series: SERIES_SELECT };
|
||||
|
||||
// Staff/supervisor/admin need the creator + notify-recipient list to populate the
|
||||
// event edit screen's Notifications step; public callers don't need this.
|
||||
const isStaffOrHigherForNotify = !!(req.user && ['admin', 'supervisor', 'staff'].includes(req.user.role));
|
||||
if (isStaffOrHigherForNotify) {
|
||||
includeObj.createdBy = { select: { id: true, name: true, email: true } };
|
||||
includeObj.notifyRecipients = { select: { id: true, name: true, email: true, role: true } };
|
||||
}
|
||||
|
||||
let event;
|
||||
|
||||
// Try to include attachments via Prisma if the client has the model
|
||||
const canUsePrismaAttachments = (prisma && prisma.eventAttachment && typeof prisma.eventAttachment.findMany === 'function');
|
||||
if (canUsePrismaAttachments) {
|
||||
try {
|
||||
// @ts-ignore - runtime guard ensures this exists
|
||||
includeObj.attachments = true;
|
||||
event = await prisma.event.findUnique({ where: { id: eventId }, include: includeObj });
|
||||
} catch (e) {
|
||||
// If relation/table does not exist (migration not deployed), fall back to fetching without attachments
|
||||
try {
|
||||
event = await prisma.event.findUnique({ where: { id: eventId }, include: { eventOptions: true, ...(isStaffOrHigherForNotify ? { createdBy: includeObj.createdBy, notifyRecipients: includeObj.notifyRecipients } : {}) } });
|
||||
} catch (e2) {
|
||||
// Notify-recipients relation not migrated yet either — fall back further
|
||||
event = await prisma.event.findUnique({ where: { id: eventId }, include: { eventOptions: true } });
|
||||
}
|
||||
// And we will source attachments from the filesystem manifest below
|
||||
}
|
||||
} else {
|
||||
// No model available on the Prisma client; fetch without attachments
|
||||
try {
|
||||
event = await prisma.event.findUnique({ where: { id: eventId }, include: { eventOptions: true, ...(isStaffOrHigherForNotify ? { createdBy: includeObj.createdBy, notifyRecipients: includeObj.notifyRecipients } : {}) } });
|
||||
} catch (e) {
|
||||
event = await prisma.event.findUnique({ where: { id: eventId }, include: { eventOptions: true } });
|
||||
}
|
||||
}
|
||||
|
||||
if (!event) {
|
||||
res.status(404);
|
||||
throw new Error('Event not found');
|
||||
}
|
||||
|
||||
// Public gating: hide inactive or not-yet-live events from everyone except staff/supervisor/admin,
|
||||
// who need to load inactive events for cashup, editing, etc. Campus-scoped staff get the
|
||||
// public view of other campuses' events (and not their notification recipients).
|
||||
const isStaffOrHigher = !!(req.user && ['admin', 'supervisor', 'staff'].includes(req.user.role)) && canView(await scopeFor(req), event.campusId);
|
||||
if (!isStaffOrHigher) {
|
||||
delete event.createdBy;
|
||||
delete event.notifyRecipients;
|
||||
// The kids check-in and volunteer tickets are handed out by staff, never sold.
|
||||
event.eventOptions = publicOptions(event);
|
||||
if (event.isActive === false) {
|
||||
res.status(404);
|
||||
throw new Error('Event not found');
|
||||
}
|
||||
// goLiveAt may not exist on older schemas — tolerate that read failing without
|
||||
// affecting the isActive gate above.
|
||||
let goLiveAt = null;
|
||||
try { goLiveAt = event.goLiveAt ? new Date(event.goLiveAt) : null; } catch (e) {}
|
||||
if (goLiveAt && new Date() < goLiveAt) {
|
||||
res.status(404);
|
||||
throw new Error('Event not found');
|
||||
}
|
||||
}
|
||||
|
||||
// Resolve attachments
|
||||
let attachments = [];
|
||||
if (event.attachments && Array.isArray(event.attachments)) {
|
||||
attachments = event.attachments;
|
||||
} else {
|
||||
// Fall back to manifest on disk if DB attachments are not available
|
||||
try {
|
||||
const uploadDir = path.join(__dirname, '..', '..', 'public', 'uploads', 'event-files');
|
||||
const manifestPath = path.join(uploadDir, `${eventId}.attachments.json`);
|
||||
if (fs.existsSync(manifestPath)) {
|
||||
const raw = fs.readFileSync(manifestPath, 'utf-8');
|
||||
const list = JSON.parse(raw) || [];
|
||||
attachments = list;
|
||||
}
|
||||
} catch {}
|
||||
}
|
||||
|
||||
// Try include form definition if available
|
||||
let form = null;
|
||||
try {
|
||||
if (prisma && prisma.eventForm && typeof prisma.eventForm.findUnique === 'function') {
|
||||
const f = await prisma.eventForm.findUnique({
|
||||
where: { eventId: eventId },
|
||||
include: { fields: true },
|
||||
});
|
||||
if (f) {
|
||||
form = {
|
||||
id: f.id,
|
||||
isRequired: !!f.isRequired,
|
||||
fields: (f.fields || []).sort((a,b) => (a.order||0)-(b.order||0)).map(fl => ({
|
||||
id: fl.id,
|
||||
type: fl.type,
|
||||
label: fl.label,
|
||||
isRequired: !!fl.isRequired,
|
||||
order: fl.order || 0,
|
||||
helpText: fl.helpText || null,
|
||||
options: fl.options || null,
|
||||
}))
|
||||
};
|
||||
}
|
||||
}
|
||||
} catch {}
|
||||
|
||||
// Compute availableCount per option and variant
|
||||
let eventOptionsWithStock = event.eventOptions || [];
|
||||
try {
|
||||
if (canIncludeVariants) {
|
||||
eventOptionsWithStock = await Promise.all((event.eventOptions || []).map(async opt => {
|
||||
// Taken = non-cancelled registrations + places held for live waitlist offers
|
||||
const { takenCount } = require('../utils/stock');
|
||||
// Picked-session options: the stock limit is places per session.
|
||||
if (sessionsUtil.isPickOption(event, opt)) {
|
||||
const sessionAvailability = {};
|
||||
if (opt.stockLimit > 0) {
|
||||
for (const s of sessionsUtil.activeSessions(event.sessions)) {
|
||||
sessionAvailability[s.id] = Math.max(0, opt.stockLimit - await takenCount({ eventOptionId: opt.id, sessionId: s.id }));
|
||||
}
|
||||
}
|
||||
return { ...opt, soldCount: 0, availableCount: null, sessionAvailability };
|
||||
}
|
||||
const soldCount = await takenCount({ eventOptionId: opt.id });
|
||||
const availableCount = opt.stockLimit > 0 ? Math.max(0, opt.stockLimit - soldCount) : null;
|
||||
|
||||
// Per-variant stock
|
||||
const variantsWithStock = await Promise.all((opt.variants || []).map(async v => {
|
||||
if (!v.stockLimit) return { ...v, soldCount: 0, availableCount: null };
|
||||
const vSold = await takenCount({ eventOptionId: opt.id, variantId: v.id });
|
||||
return { ...v, soldCount: vSold, availableCount: Math.max(0, v.stockLimit - vSold) };
|
||||
}));
|
||||
|
||||
return { ...opt, soldCount, availableCount, variants: variantsWithStock };
|
||||
}));
|
||||
}
|
||||
} catch (e) {
|
||||
// Non-fatal: fall back to options without stock info
|
||||
}
|
||||
|
||||
if (!event.sessions) event.sessions = await prisma.eventSession.findMany({ where: { eventId }, ...SESSIONS_INCLUDE }).catch(() => []);
|
||||
const bookings = event.scheduleType === 'sessions' ? await sessionsUtil.sessionBookings(eventId).catch(() => null) : null;
|
||||
const mapped = withSchedule({
|
||||
...event,
|
||||
eventOptions: eventOptionsWithStock,
|
||||
picture: toAbsoluteUrl(req, event.picture),
|
||||
attachments: (attachments || []).map(att => ({
|
||||
...att,
|
||||
url: toAbsoluteUrl(req, att.url)
|
||||
})),
|
||||
form,
|
||||
bundles: await require('./bundleController').publicBundlesForEvent(eventId).catch(() => []),
|
||||
nextInSeries: await seriesUtil.nextInSeries(event).catch(() => null),
|
||||
}, bookings);
|
||||
res.json(mapped);
|
||||
res.json(await details.getEventDetail(req.params.id, { staff: !!req.user && ['admin', 'supervisor', 'staff'].includes(req.user.role), scope: await scopeFor(req) }, (u) => toAbsoluteUrl(req, u)));
|
||||
} catch (error) {
|
||||
res.status(res.statusCode === 200 ? 400 : res.statusCode).json({ message: error.message });
|
||||
res.status(error.statusCode || 400).json({ message: error.message });
|
||||
}
|
||||
};
|
||||
|
||||
@@ -397,47 +231,12 @@ const getEventById = async (req, res) => {
|
||||
// @access Public (same visibility gating as getEventById)
|
||||
const getEventIcs = async (req, res) => {
|
||||
try {
|
||||
const eventId = req.params.id;
|
||||
const event = await prisma.event.findUnique({
|
||||
where: { id: eventId },
|
||||
select: { id: true, title: true, description: true, startDate: true, endDate: true, location: true, isActive: true, goLiveAt: true, scheduleType: true, sessions: { orderBy: { startsAt: 'asc' } } },
|
||||
});
|
||||
|
||||
if (!event) {
|
||||
res.status(404);
|
||||
throw new Error('Event not found');
|
||||
}
|
||||
|
||||
// Same public-visibility gate as getEventById — a hidden/not-yet-live event's
|
||||
// details shouldn't be enumerable via this route either.
|
||||
const isStaffOrHigher = !!(req.user && ['admin', 'supervisor', 'staff'].includes(req.user.role)) && canView(await scopeFor(req), event.campusId);
|
||||
if (!isStaffOrHigher) {
|
||||
if (event.isActive === false) {
|
||||
res.status(404);
|
||||
throw new Error('Event not found');
|
||||
}
|
||||
let goLiveAt = null;
|
||||
try { goLiveAt = event.goLiveAt ? new Date(event.goLiveAt) : null; } catch (e) {}
|
||||
if (goLiveAt && new Date() < goLiveAt) {
|
||||
res.status(404);
|
||||
throw new Error('Event not found');
|
||||
}
|
||||
}
|
||||
|
||||
const { buildEventIcs } = require('../utils/icsUtils');
|
||||
let frontendUrl = (process.env.FRONTEND_URL || process.env.APP_BASE_URL || 'http://localhost:3001').replace(/\/$/, '');
|
||||
// The ics library's url validator requires a scheme; guard against FRONTEND_URL/APP_BASE_URL
|
||||
// being configured without one (e.g. "example.com" instead of "https://example.com").
|
||||
if (!/^[a-z0-9+.-]+:\/\//i.test(frontendUrl)) {
|
||||
frontendUrl = `https://${frontendUrl}`;
|
||||
}
|
||||
const ics = buildEventIcs(event, `${frontendUrl}/events/${event.id}`);
|
||||
|
||||
const { filename, ics } = await details.eventCalendar(req.params.id, { staff: !!req.user && ['admin', 'supervisor', 'staff'].includes(req.user.role), scope: await scopeFor(req) });
|
||||
res.setHeader('Content-Type', 'text/calendar; charset=utf-8');
|
||||
res.setHeader('Content-Disposition', `attachment; filename="${event.title.replace(/[^a-z0-9 -]/gi, '').slice(0, 60) || 'event'}.ics"`);
|
||||
res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
|
||||
res.send(ics);
|
||||
} catch (error) {
|
||||
res.status(res.statusCode === 200 ? 400 : res.statusCode).json({ message: error.message });
|
||||
res.status(error.statusCode || 400).json({ message: error.message });
|
||||
}
|
||||
};
|
||||
|
||||
@@ -491,49 +290,14 @@ const deleteEvent = async (req, res) => {
|
||||
};
|
||||
|
||||
// Optional staff price from a request body: '' / null clears it, undefined leaves it.
|
||||
function parseStaffPrice(value, current = null) {
|
||||
if (value === undefined) return current;
|
||||
if (value === null || value === '') return null;
|
||||
const n = parseFloat(value);
|
||||
if (!(n >= 0)) throw new Error('Staff price must be zero or more');
|
||||
return n;
|
||||
}
|
||||
|
||||
// @desc Create event option
|
||||
// @route POST /api/events/:id/options
|
||||
// @access Private/Admin
|
||||
const createEventOption = async (req, res) => {
|
||||
try {
|
||||
const event = await prisma.event.findUnique({
|
||||
where: { id: req.params.id }
|
||||
});
|
||||
|
||||
if (!event) {
|
||||
res.status(404);
|
||||
throw new Error('Event not found');
|
||||
}
|
||||
|
||||
await assertEventOpen(req.params.id, res);
|
||||
|
||||
const { name, price, isMainTicket, stockLimit, staffPrice, sessionMode } = req.body;
|
||||
|
||||
const eventOption = await prisma.eventOption.create({
|
||||
data: {
|
||||
id: uuidv4(),
|
||||
eventId: req.params.id,
|
||||
name,
|
||||
price: parseFloat(price),
|
||||
isMainTicket: isMainTicket || false,
|
||||
stockLimit: stockLimit ? parseInt(stockLimit, 10) : 0,
|
||||
staffPrice: parseStaffPrice(staffPrice),
|
||||
sessionMode: sessionMode === 'pick' ? 'pick' : 'all',
|
||||
}
|
||||
});
|
||||
sessionsUtil.forgetSchedule(req.params.id);
|
||||
|
||||
res.status(201).json(eventOption);
|
||||
res.status(201).json(await details.createOption(req.params.id, req.body || {}));
|
||||
} catch (error) {
|
||||
res.status(400).json({ message: error.message });
|
||||
res.status(error.statusCode || 400).json({ message: error.message });
|
||||
}
|
||||
};
|
||||
|
||||
@@ -542,131 +306,9 @@ const createEventOption = async (req, res) => {
|
||||
// @access Private/Admin
|
||||
const updateEventOption = async (req, res) => {
|
||||
try {
|
||||
const eventOption = await prisma.eventOption.findUnique({
|
||||
where: { id: req.params.id },
|
||||
include: { earlyBirdTiers: true }
|
||||
});
|
||||
|
||||
if (!eventOption) {
|
||||
res.status(404);
|
||||
throw new Error('Event option not found');
|
||||
}
|
||||
|
||||
await assertEventOpen(eventOption.eventId, res);
|
||||
|
||||
const { name, price, isMainTicket, stockLimit, earlyBirdTiers, variants, staffPrice, sessionMode } = req.body;
|
||||
|
||||
const updatedEventOption = await prisma.eventOption.update({
|
||||
where: { id: req.params.id },
|
||||
data: {
|
||||
name: name !== undefined ? name : eventOption.name,
|
||||
price: price !== undefined ? parseFloat(price) : eventOption.price,
|
||||
isMainTicket: isMainTicket !== undefined ? isMainTicket : eventOption.isMainTicket,
|
||||
stockLimit: stockLimit !== undefined ? parseInt(stockLimit, 10) : eventOption.stockLimit,
|
||||
staffPrice: parseStaffPrice(staffPrice, eventOption.staffPrice),
|
||||
sessionMode: sessionMode !== undefined ? (sessionMode === 'pick' ? 'pick' : 'all') : eventOption.sessionMode,
|
||||
}
|
||||
});
|
||||
|
||||
// If earlyBirdTiers provided, upsert tiers for this option (including per-variant ones) by
|
||||
// id — mirrors the variants upsert just below. Editing tiers used to delete-and-recreate
|
||||
// every tier for the option on every save, which silently reassigned each one a brand-new
|
||||
// id; RegistrationOption/RegistrationOptionTranche.appliedTierId (onDelete: SetNull) then
|
||||
// pointed at nothing, so every past purchase under that tier lost its "early bird"
|
||||
// attribution — even for tiers the admin didn't touch — and any stock-limit count for the
|
||||
// tier reset to zero (allowing it to be oversold). Upserting by id keeps existing tiers'
|
||||
// ids stable across edits so that history stays linked.
|
||||
if (Array.isArray(earlyBirdTiers)) {
|
||||
const incomingIds = earlyBirdTiers.filter(t => t && t.id).map(t => t.id);
|
||||
const existingTiers = await prisma.earlyBirdTier.findMany({ where: { eventOptionId: updatedEventOption.id } });
|
||||
for (const et of existingTiers) {
|
||||
if (incomingIds.includes(et.id)) continue;
|
||||
// Never delete a tier that's still attributed on past purchases — just leave it
|
||||
// orphaned from the option's active tier list rather than nulling out history.
|
||||
const usageCount = await prisma.registrationOptionTranche.count({ where: { appliedTierId: et.id } });
|
||||
if (usageCount === 0) {
|
||||
try { await prisma.earlyBirdTier.delete({ where: { id: et.id } }); } catch {}
|
||||
}
|
||||
}
|
||||
for (let i = 0; i < earlyBirdTiers.length; i++) {
|
||||
const t = earlyBirdTiers[i];
|
||||
if (!t || !t.deadline || (t.price === undefined || t.price === null)) continue;
|
||||
const deadline = new Date(t.deadline);
|
||||
const p = parseFloat(t.price);
|
||||
if (!(deadline instanceof Date) || isNaN(deadline.getTime()) || !(p >= 0)) continue;
|
||||
const data = {
|
||||
eventOptionId: updatedEventOption.id,
|
||||
variantId: t.variantId || null,
|
||||
deadline,
|
||||
price: p,
|
||||
order: typeof t.order === 'number' ? t.order : i,
|
||||
stockLimit: t.stockLimit ? parseInt(t.stockLimit, 10) : 0,
|
||||
};
|
||||
if (t.id) {
|
||||
await prisma.earlyBirdTier.upsert({
|
||||
where: { id: t.id },
|
||||
update: data,
|
||||
create: { id: t.id, ...data },
|
||||
});
|
||||
} else {
|
||||
await prisma.earlyBirdTier.create({ data: { id: require('uuid').v4(), ...data } });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// If variants array provided, upsert variants
|
||||
if (Array.isArray(variants)) {
|
||||
const incomingIds = variants.filter(v => v.id).map(v => v.id);
|
||||
// Delete variants not in the new list (only if they have no registrations)
|
||||
const existingVariants = await prisma.optionVariant.findMany({ where: { eventOptionId: updatedEventOption.id } });
|
||||
for (const ev of existingVariants) {
|
||||
if (!incomingIds.includes(ev.id)) {
|
||||
const usageCount = await prisma.registrationOption.count({ where: { variantId: ev.id } });
|
||||
if (usageCount === 0) {
|
||||
await prisma.optionVariant.delete({ where: { id: ev.id } });
|
||||
}
|
||||
}
|
||||
}
|
||||
// Upsert incoming variants
|
||||
for (let i = 0; i < variants.length; i++) {
|
||||
const v = variants[i];
|
||||
if (!v.name) continue;
|
||||
const variantPrice = v.price !== undefined && v.price !== null && v.price !== '' ? parseFloat(v.price) : null;
|
||||
const variantStockLimit = v.stockLimit !== undefined ? parseInt(v.stockLimit, 10) : 0;
|
||||
const variantStaffPrice = parseStaffPrice(v.staffPrice);
|
||||
if (v.id) {
|
||||
await prisma.optionVariant.update({
|
||||
where: { id: v.id },
|
||||
data: { name: v.name, price: variantPrice, stockLimit: variantStockLimit, staffPrice: variantStaffPrice, order: i }
|
||||
});
|
||||
} else {
|
||||
await prisma.optionVariant.create({
|
||||
data: {
|
||||
id: require('uuid').v4(),
|
||||
eventOptionId: updatedEventOption.id,
|
||||
name: v.name,
|
||||
price: variantPrice,
|
||||
stockLimit: variantStockLimit,
|
||||
staffPrice: variantStaffPrice,
|
||||
order: i,
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (stockLimit !== undefined || variants !== undefined) {
|
||||
require('../utils/waitlist').queueWaitlist(eventOption.eventId);
|
||||
}
|
||||
|
||||
const refreshed = await prisma.eventOption.findUnique({
|
||||
where: { id: updatedEventOption.id },
|
||||
include: { earlyBirdTiers: true, variants: { orderBy: { order: 'asc' } } }
|
||||
});
|
||||
|
||||
res.json(refreshed);
|
||||
res.json(await details.updateOption(req.params.id, req.body || {}));
|
||||
} catch (error) {
|
||||
res.status(400).json({ message: error.message });
|
||||
res.status(error.statusCode || 400).json({ message: error.message });
|
||||
}
|
||||
};
|
||||
|
||||
@@ -675,49 +317,10 @@ const updateEventOption = async (req, res) => {
|
||||
// @access Private/Admin
|
||||
const deleteEventOption = async (req, res) => {
|
||||
try {
|
||||
const eventOption = await prisma.eventOption.findUnique({
|
||||
where: { id: req.params.id }
|
||||
});
|
||||
|
||||
if (!eventOption) {
|
||||
res.status(404);
|
||||
throw new Error('Event option not found');
|
||||
}
|
||||
|
||||
await assertEventOpen(eventOption.eventId, res);
|
||||
|
||||
// If deleting a main ticket, ensure at least one other main ticket exists for the same event
|
||||
if (eventOption.isMainTicket) {
|
||||
const otherMainCount = await prisma.eventOption.count({
|
||||
where: {
|
||||
eventId: eventOption.eventId,
|
||||
isMainTicket: true,
|
||||
NOT: { id: eventOption.id },
|
||||
}
|
||||
});
|
||||
if (otherMainCount === 0) {
|
||||
res.status(400);
|
||||
throw new Error('Cannot delete the only main ticket option');
|
||||
}
|
||||
}
|
||||
|
||||
// Check if there are any registrations using this option
|
||||
const registrationOptions = await prisma.registrationOption.findMany({
|
||||
where: { eventOptionId: req.params.id }
|
||||
});
|
||||
|
||||
if (registrationOptions.length > 0) {
|
||||
res.status(400);
|
||||
throw new Error('Cannot delete event option that has registrations');
|
||||
}
|
||||
|
||||
await prisma.eventOption.delete({
|
||||
where: { id: req.params.id }
|
||||
});
|
||||
|
||||
await details.deleteOption(req.params.id);
|
||||
res.json({ message: 'Event option removed' });
|
||||
} catch (error) {
|
||||
res.status(400).json({ message: error.message });
|
||||
res.status(error.statusCode || 400).json({ message: error.message });
|
||||
}
|
||||
};
|
||||
|
||||
@@ -726,25 +329,9 @@ const deleteEventOption = async (req, res) => {
|
||||
// @access Private/Supervisor
|
||||
const createOptionVariant = async (req, res) => {
|
||||
try {
|
||||
const eventOption = await prisma.eventOption.findUnique({ where: { id: req.params.id } });
|
||||
if (!eventOption) { res.status(404); throw new Error('Event option not found'); }
|
||||
await assertEventOpen(eventOption.eventId, res);
|
||||
const { name, price, stockLimit, order, staffPrice } = req.body;
|
||||
if (!name) { res.status(400); throw new Error('Variant name is required'); }
|
||||
const variant = await prisma.optionVariant.create({
|
||||
data: {
|
||||
id: uuidv4(),
|
||||
eventOptionId: req.params.id,
|
||||
name,
|
||||
price: price !== undefined && price !== null && price !== '' ? parseFloat(price) : null,
|
||||
stockLimit: stockLimit ? parseInt(stockLimit, 10) : 0,
|
||||
staffPrice: parseStaffPrice(staffPrice),
|
||||
order: order !== undefined ? parseInt(order, 10) : 0,
|
||||
}
|
||||
});
|
||||
res.status(201).json(variant);
|
||||
res.status(201).json(await details.createVariant(req.params.id, req.body || {}));
|
||||
} catch (error) {
|
||||
res.status(res.statusCode === 200 ? 400 : res.statusCode).json({ message: error.message });
|
||||
res.status(error.statusCode || 400).json({ message: error.message });
|
||||
}
|
||||
};
|
||||
|
||||
@@ -753,23 +340,9 @@ const createOptionVariant = async (req, res) => {
|
||||
// @access Private/Supervisor
|
||||
const updateOptionVariant = async (req, res) => {
|
||||
try {
|
||||
const variant = await prisma.optionVariant.findUnique({ where: { id: req.params.id }, include: { eventOption: { select: { eventId: true } } } });
|
||||
if (!variant) { res.status(404); throw new Error('Variant not found'); }
|
||||
await assertEventOpen(variant.eventOption.eventId, res);
|
||||
const { name, price, stockLimit, order, staffPrice } = req.body;
|
||||
const updated = await prisma.optionVariant.update({
|
||||
where: { id: req.params.id },
|
||||
data: {
|
||||
name: name !== undefined ? name : variant.name,
|
||||
staffPrice: parseStaffPrice(staffPrice, variant.staffPrice),
|
||||
price: price !== undefined ? (price === null || price === '' ? null : parseFloat(price)) : variant.price,
|
||||
stockLimit: stockLimit !== undefined ? parseInt(stockLimit, 10) : variant.stockLimit,
|
||||
order: order !== undefined ? parseInt(order, 10) : variant.order,
|
||||
}
|
||||
});
|
||||
res.json(updated);
|
||||
res.json(await details.updateVariant(req.params.id, req.body || {}));
|
||||
} catch (error) {
|
||||
res.status(res.statusCode === 200 ? 400 : res.statusCode).json({ message: error.message });
|
||||
res.status(error.statusCode || 400).json({ message: error.message });
|
||||
}
|
||||
};
|
||||
|
||||
@@ -778,25 +351,19 @@ const updateOptionVariant = async (req, res) => {
|
||||
// @access Private/Admin
|
||||
const deleteOptionVariant = async (req, res) => {
|
||||
try {
|
||||
const variant = await prisma.optionVariant.findUnique({ where: { id: req.params.id }, include: { eventOption: { select: { eventId: true } } } });
|
||||
if (!variant) { res.status(404); throw new Error('Variant not found'); }
|
||||
await assertEventOpen(variant.eventOption.eventId, res);
|
||||
const usageCount = await prisma.registrationOption.count({ where: { variantId: req.params.id } });
|
||||
if (usageCount > 0) { res.status(400); throw new Error('Cannot delete variant with existing registrations'); }
|
||||
await prisma.optionVariant.delete({ where: { id: req.params.id } });
|
||||
await details.deleteVariant(req.params.id);
|
||||
res.json({ message: 'Variant deleted' });
|
||||
} catch (error) {
|
||||
res.status(res.statusCode === 200 ? 400 : res.statusCode).json({ message: error.message });
|
||||
res.status(error.statusCode || 400).json({ message: error.message });
|
||||
}
|
||||
};
|
||||
|
||||
// File upload setup for attachments (PDFs/docs)
|
||||
// File upload for attachments (PDFs/docs), shared with /api/v2/events/{id}/attachments.
|
||||
const attachmentsStorage = multer.diskStorage({
|
||||
destination: function (req, file, cb) {
|
||||
const uploadPath = path.join(__dirname, '..', '..', 'public', 'uploads', 'event-files');
|
||||
try {
|
||||
if (!fs.existsSync(uploadPath)) fs.mkdirSync(uploadPath, { recursive: true });
|
||||
cb(null, uploadPath);
|
||||
if (!fs.existsSync(details.ATTACHMENTS_DIR)) fs.mkdirSync(details.ATTACHMENTS_DIR, { recursive: true });
|
||||
cb(null, details.ATTACHMENTS_DIR);
|
||||
} catch (err) {
|
||||
cb(err);
|
||||
}
|
||||
@@ -805,48 +372,31 @@ const attachmentsStorage = multer.diskStorage({
|
||||
// Extension only — file.originalname is untrusted and joining it into a
|
||||
// path allows `../` traversal to write outside the upload directory.
|
||||
const ext = path.extname(file.originalname).toLowerCase();
|
||||
const unique = `event-file-${Date.now()}-${crypto.randomBytes(8).toString('hex')}${ext}`;
|
||||
cb(null, unique);
|
||||
cb(null, `event-file-${Date.now()}-${crypto.randomBytes(8).toString('hex')}${ext}`);
|
||||
}
|
||||
});
|
||||
|
||||
const allowedDocs = ['.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx', '.txt', '.csv', '.zip'];
|
||||
const uploadAttachmentMulter = multer({
|
||||
storage: attachmentsStorage,
|
||||
limits: { fileSize: 20 * 1024 * 1024 }, // 20MB
|
||||
fileFilter: (req, file, cb) => {
|
||||
const ext = path.extname(file.originalname).toLowerCase();
|
||||
if (!allowedDocs.includes(ext)) {
|
||||
return cb(new Error('Unsupported file type'));
|
||||
}
|
||||
if (!details.ALLOWED_DOCS.includes(path.extname(file.originalname).toLowerCase())) return cb(new Error('Unsupported file type'));
|
||||
cb(null, true);
|
||||
}
|
||||
});
|
||||
// Saves the upload (field "file"); an error is kept on req for the handler to report.
|
||||
const receiveAttachment = (req, res, next) => uploadAttachmentMulter.single('file')(req, res, (e) => {
|
||||
if (e) req.multerError = e;
|
||||
next();
|
||||
});
|
||||
|
||||
// @desc List attachments for an event
|
||||
// @route GET /api/events/:id/attachments
|
||||
// @access Private/Supervisor (for dashboard) and could be public via event details
|
||||
const listEventAttachments = async (req, res) => {
|
||||
try {
|
||||
const eventId = req.params.id;
|
||||
// If attachments model isn't available yet (pre-migration/generate), fall back to filesystem manifest
|
||||
if (!(prisma && prisma.eventAttachment && typeof prisma.eventAttachment.findMany === 'function')) {
|
||||
try {
|
||||
const uploadDir = path.join(__dirname, '..', '..', 'public', 'uploads', 'event-files');
|
||||
const manifestPath = path.join(uploadDir, `${eventId}.attachments.json`);
|
||||
if (!fs.existsSync(manifestPath)) return res.json([]);
|
||||
const raw = fs.readFileSync(manifestPath, 'utf-8');
|
||||
const list = JSON.parse(raw);
|
||||
return res.json(list.map(att => ({ ...att, url: toAbsoluteUrl(req, att.url) })));
|
||||
} catch (e) {
|
||||
// If manifest is corrupt or unreadable, return empty list rather than failing
|
||||
return res.json([]);
|
||||
}
|
||||
}
|
||||
const items = await prisma.eventAttachment.findMany({ where: { eventId }, orderBy: { createdAt: 'desc' } });
|
||||
res.json(items.map(att => ({ ...att, url: toAbsoluteUrl(req, att.url) })));
|
||||
res.json(await details.listAttachments(req.params.id, (u) => toAbsoluteUrl(req, u)));
|
||||
} catch (error) {
|
||||
res.status(400).json({ message: error.message });
|
||||
res.status(error.statusCode || 400).json({ message: error.message });
|
||||
}
|
||||
};
|
||||
|
||||
@@ -854,97 +404,14 @@ const listEventAttachments = async (req, res) => {
|
||||
// @route POST /api/events/:id/attachments
|
||||
// @access Private/Supervisor
|
||||
const uploadEventAttachment = [
|
||||
(req, res, next) => uploadAttachmentMulter.single('file')(req, res, (err) => {
|
||||
if (err) req.multerError = err;
|
||||
next();
|
||||
}),
|
||||
receiveAttachment,
|
||||
async (req, res) => {
|
||||
try {
|
||||
if (req.multerError) throw req.multerError;
|
||||
if (!req.file) return res.status(400).json({ message: 'No file uploaded' });
|
||||
const eventId = req.params.id;
|
||||
const relUrl = `/uploads/event-files/${req.file.filename}`;
|
||||
|
||||
// Fallback: if attachments model is not available yet, store in filesystem manifest
|
||||
if (!(prisma && prisma.eventAttachment && typeof prisma.eventAttachment.create === 'function')) {
|
||||
try { console.warn('[attachments] Falling back to filesystem manifest: Prisma client lacks EventAttachment model. Ensure prisma generate ran in the deployed app dir and server restarted.'); } catch {}
|
||||
try {
|
||||
const uploadDir = path.join(__dirname, '..', '..', 'public', 'uploads', 'event-files');
|
||||
if (!fs.existsSync(uploadDir)) fs.mkdirSync(uploadDir, { recursive: true });
|
||||
const manifestPath = path.join(uploadDir, `${eventId}.attachments.json`);
|
||||
const entry = {
|
||||
id: uuidv4(),
|
||||
eventId,
|
||||
originalName: req.file.originalname,
|
||||
filename: req.file.filename,
|
||||
mimeType: req.file.mimetype,
|
||||
size: req.file.size,
|
||||
url: relUrl,
|
||||
createdAt: new Date().toISOString()
|
||||
};
|
||||
let list = [];
|
||||
if (fs.existsSync(manifestPath)) {
|
||||
try {
|
||||
list = JSON.parse(fs.readFileSync(manifestPath, 'utf-8')) || [];
|
||||
} catch {}
|
||||
}
|
||||
list.unshift(entry);
|
||||
fs.writeFileSync(manifestPath, JSON.stringify(list, null, 2), 'utf-8');
|
||||
return res.status(201).json({ ...entry, url: toAbsoluteUrl(req, entry.url) });
|
||||
} catch (e) {
|
||||
return res.status(500).json({ message: 'Failed to record attachment', detail: e?.message });
|
||||
}
|
||||
}
|
||||
|
||||
// Normal path: DB-backed
|
||||
try {
|
||||
const created = await prisma.eventAttachment.create({
|
||||
data: {
|
||||
id: uuidv4(),
|
||||
eventId,
|
||||
originalName: req.file.originalname,
|
||||
filename: req.file.filename,
|
||||
mimeType: req.file.mimetype,
|
||||
size: req.file.size,
|
||||
url: relUrl,
|
||||
}
|
||||
});
|
||||
return res.status(201).json({ ...created, url: toAbsoluteUrl(req, created.url) });
|
||||
} catch (e) {
|
||||
const msg = String(e?.message || e || '');
|
||||
const isMissingTable = msg.includes('does not exist') || msg.includes('relation') || msg.includes('P2021');
|
||||
if (isMissingTable) {
|
||||
try { console.warn('[attachments] DB create failed, falling back to filesystem manifest. Error:', msg); } catch {}
|
||||
try {
|
||||
const uploadDir = path.join(__dirname, '..', '..', 'public', 'uploads', 'event-files');
|
||||
if (!fs.existsSync(uploadDir)) fs.mkdirSync(uploadDir, { recursive: true });
|
||||
const manifestPath = path.join(uploadDir, `${eventId}.attachments.json`);
|
||||
const entry = {
|
||||
id: uuidv4(),
|
||||
eventId,
|
||||
originalName: req.file.originalname,
|
||||
filename: req.file.filename,
|
||||
mimeType: req.file.mimetype,
|
||||
size: req.file.size,
|
||||
url: relUrl,
|
||||
createdAt: new Date().toISOString()
|
||||
};
|
||||
let list = [];
|
||||
if (fs.existsSync(manifestPath)) {
|
||||
try { list = JSON.parse(fs.readFileSync(manifestPath, 'utf-8')) || []; } catch {}
|
||||
}
|
||||
list.unshift(entry);
|
||||
fs.writeFileSync(manifestPath, JSON.stringify(list, null, 2), 'utf-8');
|
||||
return res.status(201).json({ ...entry, url: toAbsoluteUrl(req, entry.url) });
|
||||
} catch (fallbackErr) {
|
||||
return res.status(500).json({ message: 'Failed to record attachment', detail: String(fallbackErr?.message || fallbackErr) });
|
||||
}
|
||||
}
|
||||
// Unknown error
|
||||
throw e;
|
||||
}
|
||||
res.status(201).json(await details.recordAttachment(req.params.id, req.file, (u) => toAbsoluteUrl(req, u)));
|
||||
} catch (error) {
|
||||
res.status(400).json({ message: error.message });
|
||||
res.status(error.statusCode || 400).json({ message: error.message });
|
||||
}
|
||||
}
|
||||
];
|
||||
@@ -954,43 +421,10 @@ const uploadEventAttachment = [
|
||||
// @access Private/Admin or Supervisor
|
||||
const deleteEventAttachment = async (req, res) => {
|
||||
try {
|
||||
const { eventId, attachmentId } = req.params;
|
||||
// If attachments model is not available yet, fall back to filesystem manifest
|
||||
if (!(prisma && prisma.eventAttachment && typeof prisma.eventAttachment.findUnique === 'function')) {
|
||||
try {
|
||||
const uploadDir = path.join(__dirname, '..', '..', 'public', 'uploads', 'event-files');
|
||||
const manifestPath = path.join(uploadDir, `${eventId}.attachments.json`);
|
||||
if (!fs.existsSync(manifestPath)) return res.status(404).json({ message: 'Attachment not found' });
|
||||
const list = JSON.parse(fs.readFileSync(manifestPath, 'utf-8')) || [];
|
||||
const idx = list.findIndex((x) => x.id === attachmentId);
|
||||
if (idx === -1) return res.status(404).json({ message: 'Attachment not found' });
|
||||
const att = list[idx];
|
||||
// Remove file on disk (best-effort)
|
||||
try {
|
||||
const filePath = path.join(uploadDir, att.filename);
|
||||
if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
|
||||
} catch {}
|
||||
// Remove from manifest
|
||||
list.splice(idx, 1);
|
||||
fs.writeFileSync(manifestPath, JSON.stringify(list, null, 2), 'utf-8');
|
||||
return res.json({ message: 'Attachment deleted' });
|
||||
} catch (e) {
|
||||
return res.status(500).json({ message: 'Failed to delete attachment', detail: e?.message });
|
||||
}
|
||||
}
|
||||
const att = await prisma.eventAttachment.findUnique({ where: { id: attachmentId } });
|
||||
if (!att || att.eventId !== eventId) {
|
||||
return res.status(404).json({ message: 'Attachment not found' });
|
||||
}
|
||||
// Remove file on disk (best-effort)
|
||||
try {
|
||||
const filePath = path.join(__dirname, '..', '..', 'public', 'uploads', 'event-files', att.filename);
|
||||
if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
|
||||
} catch {}
|
||||
await prisma.eventAttachment.delete({ where: { id: attachmentId } });
|
||||
await details.deleteAttachment(req.params.eventId, req.params.attachmentId);
|
||||
res.json({ message: 'Attachment deleted' });
|
||||
} catch (error) {
|
||||
res.status(400).json({ message: error.message });
|
||||
res.status(error.statusCode || 400).json({ message: error.message });
|
||||
}
|
||||
};
|
||||
|
||||
@@ -999,52 +433,20 @@ const deleteEventAttachment = async (req, res) => {
|
||||
// @access Private/Admin
|
||||
const attachmentsStatus = async (req, res) => {
|
||||
try {
|
||||
const hasModel = !!(prisma && prisma.eventAttachment && typeof prisma.eventAttachment.findMany === 'function');
|
||||
let tableQueryable = false;
|
||||
let probeError = null;
|
||||
if (hasModel) {
|
||||
try {
|
||||
await prisma.eventAttachment.findFirst({});
|
||||
tableQueryable = true;
|
||||
} catch (e) {
|
||||
probeError = String(e?.message || e);
|
||||
}
|
||||
}
|
||||
// Mask DB URL to avoid leaking secrets
|
||||
const dbUrl = process.env.DATABASE_URL || '';
|
||||
let dbInfo = null;
|
||||
try {
|
||||
const u = new URL(dbUrl);
|
||||
dbInfo = {
|
||||
protocol: u.protocol.replace(':',''),
|
||||
host: u.hostname,
|
||||
port: u.port || undefined,
|
||||
database: (u.pathname || '').replace(/^\//,'') || undefined,
|
||||
};
|
||||
} catch {}
|
||||
res.json({
|
||||
prismaClientHasEventAttachmentModel: hasModel,
|
||||
databaseTableQueryable: tableQueryable,
|
||||
probeError,
|
||||
database: dbInfo,
|
||||
});
|
||||
res.json(await details.attachmentsStatus());
|
||||
} catch (error) {
|
||||
res.status(400).json({ message: error.message });
|
||||
res.status(error.statusCode || 400).json({ message: error.message });
|
||||
}
|
||||
};
|
||||
|
||||
// @desc Admin-triggered sync: import manifest files into DB
|
||||
// @route POST /api/events/attachments/sync
|
||||
// @access Private/Admin
|
||||
const { syncManifestsToDb } = require('../utils/attachmentsSync');
|
||||
const attachmentsSync = async (req, res) => {
|
||||
try {
|
||||
const dryRun = String(req.query.dryRun || '').toLowerCase() === 'true';
|
||||
const remove = String(req.query.remove || '').toLowerCase() === 'true';
|
||||
const summary = await syncManifestsToDb(prisma, { dryRun, removeManifestAfterImport: remove });
|
||||
res.json({ dryRun, remove, ...summary });
|
||||
res.json(await details.syncAttachmentManifests({ dryRun: String(req.query.dryRun || '').toLowerCase() === 'true', remove: String(req.query.remove || '').toLowerCase() === 'true' }));
|
||||
} catch (error) {
|
||||
res.status(400).json({ message: error.message });
|
||||
res.status(error.statusCode || 400).json({ message: error.message });
|
||||
}
|
||||
};
|
||||
|
||||
@@ -1635,58 +1037,17 @@ const scheduleWhatsappEventAttendees = async (req, res) => {
|
||||
// catch-all [redirectUrl] route, so it's what every bot/scanner probe hitting
|
||||
// an unmatched top-level path (/wp-login.php, /.env, etc.) ends up calling.
|
||||
// Rejecting non-slug-shaped values here skips a DB round-trip for that traffic.
|
||||
const VALID_ALIAS = /^[a-zA-Z0-9_-]{1,100}$/;
|
||||
|
||||
const getEventByAlias = async (req, res) => {
|
||||
const { redirectUrl } = req.params;
|
||||
|
||||
if (!VALID_ALIAS.test(redirectUrl)) {
|
||||
return res.status(404).json({ message: 'Event not found' });
|
||||
}
|
||||
|
||||
try {
|
||||
const event = await prisma.event.findFirst({
|
||||
where: {
|
||||
redirectUrl: {
|
||||
equals: redirectUrl,
|
||||
mode: 'insensitive',
|
||||
},
|
||||
isActive: true,
|
||||
},
|
||||
select: {
|
||||
id: true,
|
||||
title: true,
|
||||
description: true,
|
||||
startDate: true,
|
||||
endDate: true,
|
||||
registrationDeadline: true,
|
||||
goLiveAt: true,
|
||||
price: true,
|
||||
picture: true,
|
||||
isActive: true,
|
||||
redirectUrl: true,
|
||||
},
|
||||
});
|
||||
|
||||
if (!event) {
|
||||
return res.status(404).json({ message: 'Event not found or inactive' });
|
||||
}
|
||||
|
||||
const now = new Date();
|
||||
const start = event.startDate ? new Date(event.startDate) : null;
|
||||
const end = event.endDate ? new Date(event.endDate) : null;
|
||||
const isLive =
|
||||
(!start || start >= now) &&
|
||||
(!end || end >= now);
|
||||
|
||||
res.json({ ...event, isLive });
|
||||
res.json(await details.eventByAlias(req.params.redirectUrl));
|
||||
} catch (error) {
|
||||
console.error('[getEventByAlias] Error:', error);
|
||||
res.status(500).json({ message: 'Internal server error' });
|
||||
res.status(error.statusCode || 500).json({ message: error.statusCode ? error.message : 'Internal server error' });
|
||||
}
|
||||
};
|
||||
|
||||
module.exports = {
|
||||
receiveAttachment,
|
||||
createEvent,
|
||||
copyEventSetupFrom,
|
||||
getEvents,
|
||||
|
||||
@@ -0,0 +1,373 @@
|
||||
/**
|
||||
* One event in full, its ticket options and variants, attachments, calendar file and short link
|
||||
* (1.51.8). Moved from eventController.js so /api/events/* (v1) and /api/v2/events/* share it.
|
||||
* The pre-migration fallbacks (attachments kept in JSON manifests on disk, clients without the
|
||||
* tier/variant models) are gone: every install has those tables.
|
||||
*/
|
||||
import fs from 'fs';
|
||||
import path from 'path';
|
||||
import { v4 as uuidv4 } from 'uuid';
|
||||
import { prisma } from '../v2/legacy';
|
||||
import { fail } from './errors';
|
||||
import { SESSIONS_INCLUDE, SERIES_SELECT, withSchedule } from './events';
|
||||
|
||||
/* eslint-disable @typescript-eslint/no-explicit-any -- the JS helpers below aren't typed yet */
|
||||
const sessionsUtil = require('../utils/sessions') as {
|
||||
isPickOption(event: any, option: any): boolean;
|
||||
activeSessions(sessions: any[]): Array<{ id: string }>;
|
||||
sessionBookings(eventId: string): Promise<Map<string, number>>;
|
||||
forgetSchedule(eventId: string): void;
|
||||
};
|
||||
const { publicOptions } = require('../utils/volunteers') as { publicOptions<O extends { id: string }>(event: any): O[] };
|
||||
const { EVENT_CAMPUS_SELECT } = require('../utils/campuses') as { EVENT_CAMPUS_SELECT: Record<string, true> };
|
||||
const { assertEventOpen } = require('../utils/cashupUtils') as { assertEventOpen(eventId: string): Promise<unknown> };
|
||||
const { takenCount } = require('../utils/stock') as { takenCount(where: object): Promise<number> };
|
||||
|
||||
/** Where uploaded attachments live (served at /uploads/event-files/…). */
|
||||
export const ATTACHMENTS_DIR = path.join(__dirname, '..', '..', 'public', 'uploads', 'event-files');
|
||||
export const ALLOWED_DOCS = ['.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx', '.txt', '.csv', '.zip'];
|
||||
|
||||
/** A stored path as an absolute URL (the caller knows the host the request came to). */
|
||||
export type UrlOf = (stored: string | null | undefined) => string | null;
|
||||
|
||||
/**
|
||||
* Who's looking: staff of a campus they may see get everything (inactive and not-yet-live
|
||||
* events, who created it, who gets its emails, the kids/volunteer tickets); everyone else gets
|
||||
* the public view and NOT_FOUND for events that aren't public.
|
||||
*/
|
||||
export type Viewer = { staff: boolean; scope: object | null };
|
||||
|
||||
const { canView } = require('../utils/campusScope') as { canView(scope: object | null, campusId: string | null): boolean };
|
||||
/** Staff see an event in full when it's at a campus they work with (or campuses are off for them). */
|
||||
const staffViewOf = (viewer: Viewer, campusId: string | null) => viewer.staff && canView(viewer.scope, campusId);
|
||||
|
||||
const notPublic = (ev: { isActive: boolean | null; goLiveAt: Date | null }) =>
|
||||
ev.isActive === false || (ev.goLiveAt != null && new Date() < new Date(ev.goLiveAt));
|
||||
|
||||
/**
|
||||
* One event in full: ticket options with what's left (per variant, and per session for
|
||||
* "pick sessions" tickets), sessions with bookings, the attendee form, attachments, bundle deals
|
||||
* on sale and the next event in its series.
|
||||
*/
|
||||
export async function getEventDetail(eventId: string, viewer: Viewer, urlOf: UrlOf) {
|
||||
const event: any = await prisma.event.findUnique({
|
||||
where: { id: eventId },
|
||||
include: {
|
||||
// (createdBy and notifyRecipients are dropped again below for the public view)
|
||||
eventOptions: { include: { earlyBirdTiers: true, variants: { orderBy: { order: 'asc' } } } },
|
||||
sessions: SESSIONS_INCLUDE,
|
||||
campus: { select: EVENT_CAMPUS_SELECT },
|
||||
series: SERIES_SELECT,
|
||||
attachments: true,
|
||||
...(viewer.staff ? {
|
||||
createdBy: { select: { id: true, name: true, email: true } },
|
||||
notifyRecipients: { select: { id: true, name: true, email: true, role: true } },
|
||||
} : {}),
|
||||
},
|
||||
});
|
||||
if (!event) return fail(404, 'Event not found');
|
||||
if (!staffViewOf(viewer, event.campusId)) {
|
||||
// Campus-scoped staff get the public view of other campuses' events.
|
||||
delete event.createdBy;
|
||||
delete event.notifyRecipients;
|
||||
if (notPublic(event)) fail(404, 'Event not found');
|
||||
// The kids check-in and volunteer tickets are handed out by staff, never sold.
|
||||
event.eventOptions = publicOptions(event);
|
||||
}
|
||||
|
||||
const f = await prisma.eventForm.findUnique({ where: { eventId }, include: { fields: true } });
|
||||
const form = f ? {
|
||||
id: f.id,
|
||||
isRequired: !!f.isRequired,
|
||||
fields: [...f.fields].sort((a, b) => (a.order || 0) - (b.order || 0)).map(fl => ({
|
||||
id: fl.id, type: fl.type, label: fl.label, isRequired: !!fl.isRequired, order: fl.order || 0, helpText: fl.helpText || null, options: fl.options || null,
|
||||
})),
|
||||
} : null;
|
||||
|
||||
// What's left per option and variant (taken = non-cancelled registrations + places held for
|
||||
// live waitlist offers). "Pick sessions" tickets have places per session instead.
|
||||
const eventOptions = await Promise.all((event.eventOptions || []).map(async (opt: any) => {
|
||||
if (sessionsUtil.isPickOption(event, opt)) {
|
||||
const sessionAvailability: Record<string, number> = {};
|
||||
if (opt.stockLimit > 0) {
|
||||
for (const s of sessionsUtil.activeSessions(event.sessions)) {
|
||||
sessionAvailability[s.id] = Math.max(0, opt.stockLimit - await takenCount({ eventOptionId: opt.id, sessionId: s.id }));
|
||||
}
|
||||
}
|
||||
return { ...opt, soldCount: 0, availableCount: null, sessionAvailability };
|
||||
}
|
||||
const soldCount = await takenCount({ eventOptionId: opt.id });
|
||||
const variants = await Promise.all((opt.variants || []).map(async (v: any) => {
|
||||
if (!v.stockLimit) return { ...v, soldCount: 0, availableCount: null };
|
||||
const vSold = await takenCount({ eventOptionId: opt.id, variantId: v.id });
|
||||
return { ...v, soldCount: vSold, availableCount: Math.max(0, v.stockLimit - vSold) };
|
||||
}));
|
||||
return { ...opt, soldCount, availableCount: opt.stockLimit > 0 ? Math.max(0, opt.stockLimit - soldCount) : null, variants };
|
||||
}));
|
||||
|
||||
const bookings = event.scheduleType === 'sessions' ? await sessionsUtil.sessionBookings(eventId).catch(() => null) : null;
|
||||
const { publicBundlesForEvent } = require('../controllers/bundleController') as { publicBundlesForEvent(id: string): Promise<unknown[]> };
|
||||
const { nextInSeries } = require('../utils/series') as { nextInSeries(ev: unknown): Promise<unknown> };
|
||||
return withSchedule({
|
||||
...event,
|
||||
eventOptions,
|
||||
picture: urlOf(event.picture),
|
||||
attachments: (event.attachments || []).map((att: any) => ({ ...att, url: urlOf(att.url) })),
|
||||
form,
|
||||
bundles: await publicBundlesForEvent(eventId).catch(() => []),
|
||||
nextInSeries: await nextInSeries(event).catch(() => null),
|
||||
}, bookings);
|
||||
}
|
||||
|
||||
/** The event (or each session of a multi-day event) as an .ics calendar file. */
|
||||
export async function eventCalendar(eventId: string, viewer: Viewer): Promise<{ filename: string; ics: string }> {
|
||||
const event = await prisma.event.findUnique({
|
||||
where: { id: eventId },
|
||||
select: { id: true, title: true, description: true, startDate: true, endDate: true, location: true, isActive: true, goLiveAt: true, scheduleType: true, campusId: true, sessions: { orderBy: { startsAt: 'asc' } } },
|
||||
});
|
||||
if (!event || (!staffViewOf(viewer, event.campusId) && notPublic(event))) return fail(404, 'Event not found');
|
||||
const { buildEventIcs } = require('../utils/icsUtils') as { buildEventIcs(ev: unknown, url: string): string };
|
||||
let frontendUrl = (process.env.FRONTEND_URL || process.env.APP_BASE_URL || 'http://localhost:3001').replace(/\/$/, '');
|
||||
// The ics library's URL check needs a scheme.
|
||||
if (!/^[a-z0-9+.-]+:\/\//i.test(frontendUrl)) frontendUrl = `https://${frontendUrl}`;
|
||||
return {
|
||||
filename: `${event.title.replace(/[^a-z0-9 -]/gi, '').slice(0, 60) || 'event'}.ics`,
|
||||
ics: buildEventIcs(event, `${frontendUrl}/events/${event.id}`),
|
||||
};
|
||||
}
|
||||
|
||||
const VALID_ALIAS = /^[a-zA-Z0-9_-]{1,100}$/;
|
||||
|
||||
/** An active event by its short link (`/camp2026`), any letter case. */
|
||||
export async function eventByAlias(alias: string) {
|
||||
if (!VALID_ALIAS.test(alias)) return fail(404, 'Event not found');
|
||||
const event = await prisma.event.findFirst({
|
||||
where: { redirectUrl: { equals: alias, mode: 'insensitive' }, isActive: true },
|
||||
select: { id: true, title: true, description: true, startDate: true, endDate: true, registrationDeadline: true, goLiveAt: true, price: true, picture: true, isActive: true, redirectUrl: true },
|
||||
});
|
||||
if (!event) return fail(404, 'Event not found or inactive');
|
||||
const now = new Date();
|
||||
const isLive = (!event.startDate || new Date(event.startDate) >= now) && (!event.endDate || new Date(event.endDate) >= now);
|
||||
return { ...event, isLive };
|
||||
}
|
||||
|
||||
// ─── Ticket options and variants ─────────────────────────────────────────────
|
||||
|
||||
/** A staff price: undefined keeps `current`, '' or null clears it. */
|
||||
export function parseStaffPrice(value: unknown, current: number | null = null): number | null {
|
||||
if (value === undefined) return current;
|
||||
if (value === null || value === '') return null;
|
||||
const n = parseFloat(String(value));
|
||||
if (!(n >= 0)) fail(400, 'Staff price must be zero or more');
|
||||
return n;
|
||||
}
|
||||
|
||||
const openEvent = async (eventId: string) => {
|
||||
try {
|
||||
await assertEventOpen(eventId);
|
||||
} catch (e: any) {
|
||||
fail(e.message === 'Event not found' ? 404 : 400, e.message);
|
||||
}
|
||||
};
|
||||
|
||||
export type OptionInput = {
|
||||
name?: string; price?: number | string; isMainTicket?: boolean; stockLimit?: number | string; staffPrice?: number | string | null;
|
||||
sessionMode?: string; earlyBirdTiers?: any[]; variants?: any[];
|
||||
};
|
||||
|
||||
export async function createOption(eventId: string, input: OptionInput) {
|
||||
const event = await prisma.event.findUnique({ where: { id: eventId }, select: { id: true } });
|
||||
if (!event) return fail(404, 'Event not found');
|
||||
await openEvent(eventId);
|
||||
if (!input.name) fail(400, 'Give the ticket a name');
|
||||
const option = await prisma.eventOption.create({
|
||||
data: {
|
||||
id: uuidv4(), eventId, name: String(input.name), price: parseFloat(String(input.price ?? 0)) || 0, isMainTicket: input.isMainTicket || false,
|
||||
stockLimit: input.stockLimit ? parseInt(String(input.stockLimit), 10) : 0, staffPrice: parseStaffPrice(input.staffPrice),
|
||||
sessionMode: input.sessionMode === 'pick' ? 'pick' : 'all',
|
||||
},
|
||||
});
|
||||
sessionsUtil.forgetSchedule(eventId);
|
||||
return option;
|
||||
}
|
||||
|
||||
/**
|
||||
* Changes a ticket option, and — when sent — its early-bird tiers and variants. Tiers and
|
||||
* variants are upserted by id, so purchases keep pointing at the tier they were bought under;
|
||||
* ones left out are removed only when nothing was bought under them.
|
||||
*/
|
||||
export async function updateOption(optionId: string, input: OptionInput) {
|
||||
const existing = await prisma.eventOption.findUnique({ where: { id: optionId } });
|
||||
if (!existing) return fail(404, 'Event option not found');
|
||||
await openEvent(existing.eventId);
|
||||
const updated = await prisma.eventOption.update({
|
||||
where: { id: optionId },
|
||||
data: {
|
||||
name: input.name !== undefined ? String(input.name) : existing.name,
|
||||
price: input.price !== undefined ? parseFloat(String(input.price)) : existing.price,
|
||||
isMainTicket: input.isMainTicket !== undefined ? input.isMainTicket : existing.isMainTicket,
|
||||
stockLimit: input.stockLimit !== undefined ? parseInt(String(input.stockLimit), 10) : existing.stockLimit,
|
||||
staffPrice: parseStaffPrice(input.staffPrice, existing.staffPrice),
|
||||
sessionMode: input.sessionMode !== undefined ? (input.sessionMode === 'pick' ? 'pick' : 'all') : existing.sessionMode,
|
||||
},
|
||||
});
|
||||
|
||||
// Early-bird tiers: deleting and recreating them would give every tier a new id and cut past
|
||||
// purchases off from the tier they were bought under (and reset its stock count).
|
||||
if (Array.isArray(input.earlyBirdTiers)) {
|
||||
const incoming = input.earlyBirdTiers.filter(t => t && t.id).map(t => t.id);
|
||||
for (const et of await prisma.earlyBirdTier.findMany({ where: { eventOptionId: optionId } })) {
|
||||
if (incoming.includes(et.id)) continue;
|
||||
// Never delete a tier still attributed on past purchases.
|
||||
if (await prisma.registrationOptionTranche.count({ where: { appliedTierId: et.id } }) === 0) {
|
||||
await prisma.earlyBirdTier.delete({ where: { id: et.id } }).catch(() => {});
|
||||
}
|
||||
}
|
||||
for (let i = 0; i < input.earlyBirdTiers.length; i++) {
|
||||
const t = input.earlyBirdTiers[i];
|
||||
if (!t || !t.deadline || t.price === undefined || t.price === null) continue;
|
||||
const deadline = new Date(t.deadline);
|
||||
const p = parseFloat(t.price);
|
||||
if (isNaN(deadline.getTime()) || !(p >= 0)) continue;
|
||||
const data = { eventOptionId: optionId, variantId: t.variantId || null, deadline, price: p, order: typeof t.order === 'number' ? t.order : i, stockLimit: t.stockLimit ? parseInt(t.stockLimit, 10) : 0 };
|
||||
if (t.id) await prisma.earlyBirdTier.upsert({ where: { id: t.id }, update: data, create: { id: t.id, ...data } });
|
||||
else await prisma.earlyBirdTier.create({ data: { id: uuidv4(), ...data } });
|
||||
}
|
||||
}
|
||||
|
||||
// Variants: upserted by id; ones left out are deleted only when nobody has bought them.
|
||||
if (Array.isArray(input.variants)) {
|
||||
const incoming = input.variants.filter(v => v.id).map(v => v.id);
|
||||
for (const ov of await prisma.optionVariant.findMany({ where: { eventOptionId: optionId } })) {
|
||||
if (!incoming.includes(ov.id) && await prisma.registrationOption.count({ where: { variantId: ov.id } }) === 0) {
|
||||
await prisma.optionVariant.delete({ where: { id: ov.id } });
|
||||
}
|
||||
}
|
||||
for (let i = 0; i < input.variants.length; i++) {
|
||||
const v = input.variants[i];
|
||||
if (!v.name) continue;
|
||||
const data = {
|
||||
name: v.name,
|
||||
price: v.price !== undefined && v.price !== null && v.price !== '' ? parseFloat(v.price) : null,
|
||||
stockLimit: v.stockLimit !== undefined ? parseInt(v.stockLimit, 10) : 0,
|
||||
staffPrice: parseStaffPrice(v.staffPrice),
|
||||
order: i,
|
||||
};
|
||||
if (v.id) await prisma.optionVariant.update({ where: { id: v.id }, data });
|
||||
else await prisma.optionVariant.create({ data: { id: uuidv4(), eventOptionId: optionId, ...data } });
|
||||
}
|
||||
}
|
||||
|
||||
if (input.stockLimit !== undefined || input.variants !== undefined) {
|
||||
(require('../utils/waitlist') as { queueWaitlist(eventId: string): void }).queueWaitlist(existing.eventId);
|
||||
}
|
||||
return prisma.eventOption.findUniqueOrThrow({ where: { id: updated.id }, include: { earlyBirdTiers: true, variants: { orderBy: { order: 'asc' } } } });
|
||||
}
|
||||
|
||||
/** Removes a ticket option nobody has bought (and never the event's only main ticket). */
|
||||
export async function deleteOption(optionId: string) {
|
||||
const option = await prisma.eventOption.findUnique({ where: { id: optionId } });
|
||||
if (!option) return fail(404, 'Event option not found');
|
||||
await openEvent(option.eventId);
|
||||
if (option.isMainTicket) {
|
||||
const others = await prisma.eventOption.count({ where: { eventId: option.eventId, isMainTicket: true, NOT: { id: option.id } } });
|
||||
if (others === 0) fail(400, 'Cannot delete the only main ticket option');
|
||||
}
|
||||
if (await prisma.registrationOption.count({ where: { eventOptionId: optionId } }) > 0) fail(400, 'Cannot delete event option that has registrations');
|
||||
await prisma.eventOption.delete({ where: { id: optionId } });
|
||||
}
|
||||
|
||||
export type VariantInput = { name?: string; price?: number | string | null; stockLimit?: number | string; order?: number | string; staffPrice?: number | string | null };
|
||||
|
||||
export async function createVariant(optionId: string, input: VariantInput) {
|
||||
const option = await prisma.eventOption.findUnique({ where: { id: optionId } });
|
||||
if (!option) return fail(404, 'Event option not found');
|
||||
await openEvent(option.eventId);
|
||||
if (!input.name) fail(400, 'Variant name is required');
|
||||
return prisma.optionVariant.create({
|
||||
data: {
|
||||
id: uuidv4(), eventOptionId: optionId, name: String(input.name),
|
||||
price: input.price !== undefined && input.price !== null && input.price !== '' ? parseFloat(String(input.price)) : null,
|
||||
stockLimit: input.stockLimit ? parseInt(String(input.stockLimit), 10) : 0,
|
||||
staffPrice: parseStaffPrice(input.staffPrice),
|
||||
order: input.order !== undefined ? parseInt(String(input.order), 10) : 0,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
export async function updateVariant(variantId: string, input: VariantInput) {
|
||||
const variant = await prisma.optionVariant.findUnique({ where: { id: variantId }, include: { eventOption: { select: { eventId: true } } } });
|
||||
if (!variant) return fail(404, 'Variant not found');
|
||||
await openEvent(variant.eventOption.eventId);
|
||||
return prisma.optionVariant.update({
|
||||
where: { id: variantId },
|
||||
data: {
|
||||
name: input.name !== undefined ? String(input.name) : variant.name,
|
||||
staffPrice: parseStaffPrice(input.staffPrice, variant.staffPrice),
|
||||
price: input.price !== undefined ? (input.price === null || input.price === '' ? null : parseFloat(String(input.price))) : variant.price,
|
||||
stockLimit: input.stockLimit !== undefined ? parseInt(String(input.stockLimit), 10) : variant.stockLimit,
|
||||
order: input.order !== undefined ? parseInt(String(input.order), 10) : variant.order,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
/** Removes a variant nobody has bought. */
|
||||
export async function deleteVariant(variantId: string) {
|
||||
const variant = await prisma.optionVariant.findUnique({ where: { id: variantId }, include: { eventOption: { select: { eventId: true } } } });
|
||||
if (!variant) return fail(404, 'Variant not found');
|
||||
await openEvent(variant.eventOption.eventId);
|
||||
if (await prisma.registrationOption.count({ where: { variantId } }) > 0) fail(400, 'Cannot delete variant with existing registrations');
|
||||
await prisma.optionVariant.delete({ where: { id: variantId } });
|
||||
}
|
||||
|
||||
// ─── Attachments ─────────────────────────────────────────────────────────────
|
||||
|
||||
export async function listAttachments(eventId: string, urlOf: UrlOf) {
|
||||
const items = await prisma.eventAttachment.findMany({ where: { eventId }, orderBy: { createdAt: 'desc' } });
|
||||
return items.map(att => ({ ...att, url: urlOf(att.url) }));
|
||||
}
|
||||
|
||||
/** Records a file multer has already saved in ATTACHMENTS_DIR. */
|
||||
export async function recordAttachment(eventId: string, file: { originalname: string; filename: string; mimetype: string; size: number }, urlOf: UrlOf) {
|
||||
const event = await prisma.event.findUnique({ where: { id: eventId }, select: { id: true } });
|
||||
if (!event) {
|
||||
fs.promises.unlink(path.join(ATTACHMENTS_DIR, file.filename)).catch(() => {});
|
||||
return fail(404, 'Event not found');
|
||||
}
|
||||
const created = await prisma.eventAttachment.create({
|
||||
data: { id: uuidv4(), eventId, originalName: file.originalname, filename: file.filename, mimeType: file.mimetype, size: file.size, url: `/uploads/event-files/${file.filename}` },
|
||||
});
|
||||
return { ...created, url: urlOf(created.url) };
|
||||
}
|
||||
|
||||
export async function deleteAttachment(eventId: string, attachmentId: string) {
|
||||
const att = await prisma.eventAttachment.findUnique({ where: { id: attachmentId } });
|
||||
if (!att || att.eventId !== eventId) return fail(404, 'Attachment not found');
|
||||
// The file goes too (best effort; the record is what the site shows).
|
||||
await fs.promises.unlink(path.join(ATTACHMENTS_DIR, att.filename)).catch(() => {});
|
||||
await prisma.eventAttachment.delete({ where: { id: attachmentId } });
|
||||
}
|
||||
|
||||
/** Admin diagnostics: whether the attachments table answers, and which database it is (no secrets). */
|
||||
export async function attachmentsStatus() {
|
||||
let tableQueryable = false;
|
||||
let probeError: string | null = null;
|
||||
try {
|
||||
await prisma.eventAttachment.findFirst({});
|
||||
tableQueryable = true;
|
||||
} catch (e: any) {
|
||||
probeError = String(e?.message || e);
|
||||
}
|
||||
let database: Record<string, string | undefined> | null = null;
|
||||
try {
|
||||
const u = new URL(process.env.DATABASE_URL || '');
|
||||
database = { protocol: u.protocol.replace(':', ''), host: u.hostname, port: u.port || undefined, database: u.pathname.replace(/^\//, '') || undefined };
|
||||
} catch { /* not a URL */ }
|
||||
return { prismaClientHasEventAttachmentModel: true, databaseTableQueryable: tableQueryable, probeError, database };
|
||||
}
|
||||
|
||||
/** Imports attachments still listed in old JSON manifests on disk into the database. */
|
||||
export async function syncAttachmentManifests(opts: { dryRun: boolean; remove: boolean }) {
|
||||
const { syncManifestsToDb } = require('../utils/attachmentsSync') as { syncManifestsToDb(db: unknown, o: { dryRun: boolean; removeManifestAfterImport: boolean }): Promise<Record<string, unknown>> };
|
||||
return { ...opts, ...(await syncManifestsToDb(prisma, { dryRun: opts.dryRun, removeManifestAfterImport: opts.remove })) };
|
||||
}
|
||||
@@ -7,6 +7,7 @@ import auth from '../middleware/authMiddleware';
|
||||
// Resources: importing one registers its routes.
|
||||
// eventsManage first: /events/manage must match before /events/:id.
|
||||
import './resources/eventsManage';
|
||||
import './resources/eventDetails';
|
||||
import './resources/events';
|
||||
import './resources/me';
|
||||
import './resources/registrations';
|
||||
|
||||
@@ -71,9 +71,13 @@ export function buildOpenApi(opts: { version: string; serverUrl?: string; list?:
|
||||
operationId: `${def.method}${path.replace(/[{}]/g, '').split('/').map(s => s.charAt(0).toUpperCase() + s.slice(1)).join('')}`,
|
||||
...(secured ? { security: [{ bearerAuth: [] }] } : def.access === 'optional' ? { security: [{}, { bearerAuth: [] }] } : {}),
|
||||
parameters: parameters(def),
|
||||
...(def.body ? { requestBody: { required: true, content: { 'application/json': { schema: toSchema(def.body, 'input') } } } } : {}),
|
||||
...(def.upload
|
||||
? { requestBody: { required: true, content: { 'multipart/form-data': { schema: { type: 'object', required: [def.upload.field], properties: { [def.upload.field]: { type: 'string', format: 'binary', description: def.upload.description } } } } } } }
|
||||
: def.body ? { requestBody: { required: true, content: { 'application/json': { schema: toSchema(def.body, 'input') } } } } : {}),
|
||||
responses: {
|
||||
[String(def.status ?? 200)]: { description: 'OK', content: { 'application/json': { schema: toSchema(def.response, 'output') } } },
|
||||
[String(def.status ?? 200)]: def.file
|
||||
? { description: 'The file', content: { [def.file.contentType]: { schema: { type: 'string' } } } }
|
||||
: { description: 'OK', content: { 'application/json': { schema: toSchema(def.response, 'output') } } },
|
||||
...(def.params || def.query || def.body ? { 400: errorResponse('Validation failed (VALIDATION_FAILED)') } : {}),
|
||||
...(secured ? { 401: errorResponse('Not signed in (UNAUTHENTICATED)') } : {}),
|
||||
...(secured && def.access !== 'user' ? { 403: errorResponse('Not allowed for this role (FORBIDDEN)') } : {}),
|
||||
|
||||
@@ -0,0 +1,282 @@
|
||||
import { z } from 'zod';
|
||||
import type { Request } from 'express';
|
||||
import { defineRoute, fileResponse, type ApiUser } from '../route';
|
||||
import { ApiError } from '../errors';
|
||||
import { single } from '../paging';
|
||||
import { absoluteUrl, id, idParams, isoDate } from '../schemas';
|
||||
import * as details from '../../services/eventDetails';
|
||||
import { managedEvent } from './eventsManage';
|
||||
|
||||
/* eslint-disable @typescript-eslint/no-explicit-any -- stored records are passed through */
|
||||
const campusScope = require('../../utils/campusScope') as {
|
||||
scopeFor(req: unknown): Promise<object | null>;
|
||||
scopeEvent(opts?: { need?: 'view' | 'manage'; resolve?: string; from?: (req: any) => unknown }): any;
|
||||
};
|
||||
// The same multer step as v1 (field "file"; PDFs, Office files, text, CSV, ZIP; 20 MB).
|
||||
const { receiveAttachment } = require('../../controllers/eventController') as { receiveAttachment: any };
|
||||
|
||||
const urlOf = (req: Request) => (u: string | null | undefined) => absoluteUrl(req, u);
|
||||
const plain = <T>(v: T): any => JSON.parse(JSON.stringify(v));
|
||||
const viewerOf = async (req: Request, user: ApiUser | null) => ({ staff: !!user && ['admin', 'supervisor', 'staff'].includes(user.role), scope: await campusScope.scopeFor(req) });
|
||||
|
||||
// ─── The event in full, calendar file, short link ──────────────────────────────
|
||||
|
||||
export const full = defineRoute({
|
||||
method: 'get',
|
||||
path: '/events/:id/full',
|
||||
tag: 'Events',
|
||||
summary: 'One event in full',
|
||||
description: [
|
||||
'What the registration page and the set-up screens need: ticket options with what\'s left (per variant, and per session for "pick sessions" tickets), early-bird tiers, sessions with bookings, the attendee form, attachments, bundle deals on sale and the next event in its series.',
|
||||
'Staff (of a campus they work with) also get inactive and not-yet-live events, who created it, who gets its emails, and the kids/volunteer tickets. Everyone else gets NOT_FOUND for events that aren\'t public.',
|
||||
].join('\n\n'),
|
||||
access: 'optional',
|
||||
params: idParams,
|
||||
response: single(managedEvent.extend({
|
||||
form: z.looseObject({ id, isRequired: z.boolean(), fields: z.array(z.looseObject({ id, type: z.string(), label: z.string() })) }).nullable(),
|
||||
attachments: z.array(z.looseObject({ id, originalName: z.string(), url: z.string().nullable() })),
|
||||
})),
|
||||
async handler({ params, user, req }) {
|
||||
return { data: plain(await details.getEventDetail(params.id, await viewerOf(req, user), urlOf(req))) };
|
||||
},
|
||||
});
|
||||
|
||||
export const calendar = defineRoute({
|
||||
method: 'get',
|
||||
path: '/events/:id/calendar.ics',
|
||||
tag: 'Events',
|
||||
summary: 'The event as a calendar file',
|
||||
description: 'An .ics file (each session for a multi-day event). Same visibility as the event.',
|
||||
access: 'optional',
|
||||
file: { contentType: 'text/calendar' },
|
||||
params: idParams,
|
||||
response: fileResponse,
|
||||
async handler({ params, user, req }) {
|
||||
const { filename, ics } = await details.eventCalendar(params.id, await viewerOf(req, user));
|
||||
return { data: { contentType: 'text/calendar; charset=utf-8', filename, body: ics } };
|
||||
},
|
||||
});
|
||||
|
||||
export const byAlias = defineRoute({
|
||||
method: 'get',
|
||||
path: '/events/by-alias/:alias',
|
||||
tag: 'Events',
|
||||
summary: 'An event by its short link',
|
||||
description: 'The part after the site address (`/camp2026`), any letter case. Active events only.',
|
||||
access: 'public',
|
||||
params: z.object({ alias: z.string().min(1).max(100).describe('The short link, e.g. camp2026') }),
|
||||
response: single(z.object({
|
||||
id, title: z.string(), description: z.string().nullable(), startDate: isoDate, endDate: isoDate, registrationDeadline: isoDate.nullable(),
|
||||
goLiveAt: isoDate.nullable(), price: z.number(), picture: z.string().nullable(), redirectUrl: z.string().nullable(),
|
||||
isLive: z.boolean().describe('Not over yet'),
|
||||
})),
|
||||
async handler({ params, req }) {
|
||||
const ev = plain(await details.eventByAlias(params.alias));
|
||||
return { data: { ...ev, picture: absoluteUrl(req, ev.picture) } };
|
||||
},
|
||||
});
|
||||
|
||||
// ─── Ticket options and variants ─────────────────────────────────────────────
|
||||
|
||||
const variant = z.looseObject({ id, name: z.string(), price: z.number().nullable(), stockLimit: z.number().int(), staffPrice: z.number().nullable(), order: z.number().int() });
|
||||
const tier = z.looseObject({ id, deadline: isoDate, price: z.number(), stockLimit: z.number().int(), variantId: id.nullable() });
|
||||
const ticketOption = z.looseObject({
|
||||
id, eventId: id, name: z.string(), price: z.number(), isMainTicket: z.boolean(), stockLimit: z.number().int(), staffPrice: z.number().nullable(),
|
||||
sessionMode: z.enum(['all', 'pick']), earlyBirdTiers: z.array(tier).optional(), variants: z.array(variant).optional(),
|
||||
});
|
||||
const money = z.union([z.number(), z.string().max(20)]);
|
||||
const optionBody = z.object({
|
||||
name: z.string().trim().min(1).max(120),
|
||||
price: money,
|
||||
isMainTicket: z.boolean().optional(),
|
||||
stockLimit: z.union([z.number().int().min(0), z.string().max(10)]).optional().describe('0 = no limit'),
|
||||
staffPrice: money.nullable().optional().describe('What staff pay (empty = the normal price)'),
|
||||
sessionMode: z.enum(['all', 'pick']).optional().describe('"pick" = buyers choose sessions (multi-day events)'),
|
||||
});
|
||||
const variantBody = z.object({
|
||||
name: z.string().trim().min(1).max(120),
|
||||
price: money.nullable().optional().describe('Empty = the option\'s price'),
|
||||
stockLimit: z.union([z.number().int().min(0), z.string().max(10)]).optional(),
|
||||
staffPrice: money.nullable().optional(),
|
||||
order: z.union([z.number().int(), z.string().max(10)]).optional(),
|
||||
});
|
||||
|
||||
export const createOption = defineRoute({
|
||||
method: 'post',
|
||||
path: '/events/:id/ticket-options',
|
||||
tag: 'Events (staff)',
|
||||
summary: 'Add a ticket option',
|
||||
access: 'supervisor',
|
||||
campusScope: 'scopeEvent(manage)',
|
||||
middleware: [campusScope.scopeEvent({ need: 'manage' })],
|
||||
status: 201,
|
||||
params: idParams,
|
||||
body: optionBody,
|
||||
response: single(ticketOption),
|
||||
async handler({ params, body }) {
|
||||
return { data: plain(await details.createOption(params.id, body)) };
|
||||
},
|
||||
});
|
||||
|
||||
export const updateOption = defineRoute({
|
||||
method: 'patch',
|
||||
path: '/ticket-options/:id',
|
||||
tag: 'Events (staff)',
|
||||
summary: 'Change a ticket option',
|
||||
description: 'Only what\'s sent changes. `earlyBirdTiers` and `variants`, when sent, are the full lists: kept by id, added without one, and ones left out removed when nothing was bought under them.',
|
||||
access: 'supervisor',
|
||||
campusScope: 'scopeEvent(eventOption, manage)',
|
||||
middleware: [campusScope.scopeEvent({ resolve: 'eventOption', need: 'manage' })],
|
||||
params: idParams,
|
||||
body: optionBody.partial().extend({
|
||||
earlyBirdTiers: z.array(z.looseObject({ id: id.optional(), deadline: z.string().max(40), price: money, stockLimit: z.union([z.number(), z.string()]).optional(), variantId: id.nullable().optional() })).max(50).optional(),
|
||||
variants: z.array(variantBody.extend({ id: id.optional() })).max(100).optional(),
|
||||
}),
|
||||
response: single(ticketOption),
|
||||
async handler({ params, body }) {
|
||||
return { data: plain(await details.updateOption(params.id, body)) };
|
||||
},
|
||||
});
|
||||
|
||||
export const deleteOption = defineRoute({
|
||||
method: 'delete',
|
||||
path: '/ticket-options/:id',
|
||||
tag: 'Events (staff)',
|
||||
summary: 'Remove a ticket option',
|
||||
description: 'Admins only. Not one anybody has bought, and never the event\'s only main ticket.',
|
||||
access: 'admin',
|
||||
params: idParams,
|
||||
response: single(z.object({ id, deleted: z.literal(true) })),
|
||||
async handler({ params }) {
|
||||
await details.deleteOption(params.id);
|
||||
return { data: { id: params.id, deleted: true as const } };
|
||||
},
|
||||
});
|
||||
|
||||
export const createVariant = defineRoute({
|
||||
method: 'post',
|
||||
path: '/ticket-options/:id/variants',
|
||||
tag: 'Events (staff)',
|
||||
summary: 'Add a variant (e.g. a T-shirt size)',
|
||||
access: 'supervisor',
|
||||
campusScope: 'scopeEvent(eventOption, manage)',
|
||||
middleware: [campusScope.scopeEvent({ resolve: 'eventOption', need: 'manage' })],
|
||||
status: 201,
|
||||
params: idParams,
|
||||
body: variantBody,
|
||||
response: single(variant),
|
||||
async handler({ params, body }) {
|
||||
return { data: plain(await details.createVariant(params.id, body)) };
|
||||
},
|
||||
});
|
||||
|
||||
export const updateVariant = defineRoute({
|
||||
method: 'patch',
|
||||
path: '/variants/:id',
|
||||
tag: 'Events (staff)',
|
||||
summary: 'Change a variant',
|
||||
access: 'supervisor',
|
||||
campusScope: 'scopeEvent(optionVariant, manage)',
|
||||
middleware: [campusScope.scopeEvent({ resolve: 'optionVariant', need: 'manage' })],
|
||||
params: idParams,
|
||||
body: variantBody.partial(),
|
||||
response: single(variant),
|
||||
async handler({ params, body }) {
|
||||
return { data: plain(await details.updateVariant(params.id, body)) };
|
||||
},
|
||||
});
|
||||
|
||||
export const deleteVariant = defineRoute({
|
||||
method: 'delete',
|
||||
path: '/variants/:id',
|
||||
tag: 'Events (staff)',
|
||||
summary: 'Remove a variant',
|
||||
description: 'Admins only, and not one anybody has bought.',
|
||||
access: 'admin',
|
||||
params: idParams,
|
||||
response: single(z.object({ id, deleted: z.literal(true) })),
|
||||
async handler({ params }) {
|
||||
await details.deleteVariant(params.id);
|
||||
return { data: { id: params.id, deleted: true as const } };
|
||||
},
|
||||
});
|
||||
|
||||
// ─── Attachments ─────────────────────────────────────────────────────────────
|
||||
|
||||
const attachment = z.object({ id, eventId: id, originalName: z.string(), filename: z.string(), mimeType: z.string(), size: z.number().int(), url: z.string().nullable(), createdAt: isoDate });
|
||||
|
||||
export const listAttachments = defineRoute({
|
||||
method: 'get',
|
||||
path: '/events/:id/attachments',
|
||||
tag: 'Events',
|
||||
summary: 'An event\'s attachments',
|
||||
description: 'Files for attendees (programmes, packing lists…), newest first.',
|
||||
access: 'public',
|
||||
params: idParams,
|
||||
response: z.object({ data: z.array(attachment) }),
|
||||
async handler({ params, req }) {
|
||||
return { data: plain(await details.listAttachments(params.id, urlOf(req))) };
|
||||
},
|
||||
});
|
||||
|
||||
export const uploadAttachment = defineRoute({
|
||||
method: 'post',
|
||||
path: '/events/:id/attachments',
|
||||
tag: 'Events (staff)',
|
||||
summary: 'Attach a file to an event',
|
||||
access: 'supervisor',
|
||||
campusScope: 'scopeEvent(manage)',
|
||||
middleware: [campusScope.scopeEvent({ need: 'manage' }), receiveAttachment],
|
||||
upload: { field: 'file', description: 'PDF, Word, Excel, PowerPoint, text, CSV or ZIP, up to 20 MB' },
|
||||
status: 201,
|
||||
params: idParams,
|
||||
response: single(attachment),
|
||||
async handler({ params, req }) {
|
||||
const r = req as Request & { multerError?: Error; file?: { originalname: string; filename: string; mimetype: string; size: number } };
|
||||
if (r.multerError) throw new ApiError('VALIDATION_FAILED', r.multerError.message, { file: r.multerError.message });
|
||||
if (!r.file) throw new ApiError('VALIDATION_FAILED', 'No file uploaded', { file: 'Choose a file' });
|
||||
return { data: plain(await details.recordAttachment(params.id, r.file, urlOf(req))) };
|
||||
},
|
||||
});
|
||||
|
||||
export const deleteAttachment = defineRoute({
|
||||
method: 'delete',
|
||||
path: '/events/:id/attachments/:attachmentId',
|
||||
tag: 'Events (staff)',
|
||||
summary: 'Remove an attachment',
|
||||
access: 'supervisor',
|
||||
campusScope: 'scopeEvent(manage)',
|
||||
middleware: [campusScope.scopeEvent({ need: 'manage' })],
|
||||
params: z.object({ id, attachmentId: id }),
|
||||
response: single(z.object({ id, deleted: z.literal(true) })),
|
||||
async handler({ params }) {
|
||||
await details.deleteAttachment(params.id, params.attachmentId);
|
||||
return { data: { id: params.attachmentId, deleted: true as const } };
|
||||
},
|
||||
});
|
||||
|
||||
export const attachmentsStatus = defineRoute({
|
||||
method: 'get',
|
||||
path: '/attachments/status',
|
||||
tag: 'Admin',
|
||||
summary: 'Attachments diagnostics',
|
||||
access: 'admin',
|
||||
response: single(z.looseObject({ databaseTableQueryable: z.boolean(), probeError: z.string().nullable() })),
|
||||
async handler() {
|
||||
return { data: plain(await details.attachmentsStatus()) };
|
||||
},
|
||||
});
|
||||
|
||||
export const attachmentsSync = defineRoute({
|
||||
method: 'post',
|
||||
path: '/attachments/sync',
|
||||
tag: 'Admin',
|
||||
summary: 'Import attachments from old manifests',
|
||||
description: 'Attachments recorded in JSON files on disk by very old versions go into the database. `dryRun` only reports; `remove` deletes each manifest once imported.',
|
||||
access: 'admin',
|
||||
body: z.object({ dryRun: z.boolean().default(false), remove: z.boolean().default(false) }),
|
||||
response: single(z.looseObject({ dryRun: z.boolean(), remove: z.boolean() })),
|
||||
async handler({ body }) {
|
||||
return { data: plain(await details.syncAttachmentManifests(body)) };
|
||||
},
|
||||
});
|
||||
@@ -50,6 +50,13 @@ export type RouteDef<P extends Schema | undefined, Q extends Schema | undefined,
|
||||
status?: number;
|
||||
/** Runs after the access check, e.g. a rate limiter. */
|
||||
middleware?: RequestHandler[];
|
||||
/** A multipart upload (the file in `field`, saved by a multer step in `middleware`). */
|
||||
upload?: { field: string; description: string };
|
||||
/**
|
||||
* The answer is a file, not JSON: the handler returns `{ data: { contentType, filename, body } }`
|
||||
* and `response` is `fileResponse`. `contentType` here is what the docs show.
|
||||
*/
|
||||
file?: { contentType: string };
|
||||
handler: (ctx: Ctx<Infer<P>, Infer<Q>, Infer<B>>) => Promise<z.input<R>> | z.input<R>;
|
||||
};
|
||||
|
||||
@@ -97,6 +104,13 @@ export function mount(router: Router, list: AnyRoute[] = routes): void {
|
||||
console.error(`[api/v2] ${def.method.toUpperCase()} ${def.path}: response doesn't match its schema`, checked.error.issues);
|
||||
throw new ApiError('INTERNAL', 'Something went wrong on the server.');
|
||||
}
|
||||
if (def.file) {
|
||||
const f = (checked.data as { data: { contentType: string; filename: string; body: string } }).data;
|
||||
res.setHeader('Content-Type', f.contentType);
|
||||
res.setHeader('Content-Disposition', `attachment; filename="${f.filename.replace(/"/g, '')}"`);
|
||||
res.status(def.status ?? 200).send(f.body);
|
||||
return;
|
||||
}
|
||||
res.status(def.status ?? 200).json(checked.data);
|
||||
} catch (err) {
|
||||
next(err);
|
||||
@@ -105,3 +119,6 @@ export function mount(router: Router, list: AnyRoute[] = routes): void {
|
||||
router[def.method](def.path, ...ACCESS[def.access], ...(def.middleware ?? []), run);
|
||||
}
|
||||
}
|
||||
|
||||
/** The `response` of a `file` route: what the handler hands back to be sent as a download. */
|
||||
export const fileResponse = z.object({ data: z.object({ contentType: z.string(), filename: z.string(), body: z.string() }) });
|
||||
|
||||
@@ -53,6 +53,18 @@ jest.mock('../src/utils/campusScope', () => ({
|
||||
const mockEvents = { listManagedEvents: jest.fn(), createEvent: jest.fn(), updateEvent: jest.fn(), deactivateEvent: jest.fn(), getNotifyRecipients: jest.fn(), setNotifyRecipients: jest.fn(), copySetupFrom: jest.fn() };
|
||||
jest.mock('../src/services/events', () => Object.fromEntries(Object.keys(mockEvents).map(k => [k, (...a: unknown[]) => (mockEvents as Record<string, jest.Mock>)[k](...a)])));
|
||||
|
||||
const mockDetails = {
|
||||
getEventDetail: jest.fn(), eventCalendar: jest.fn(), eventByAlias: jest.fn(), createOption: jest.fn(), updateOption: jest.fn(), deleteOption: jest.fn(),
|
||||
createVariant: jest.fn(), updateVariant: jest.fn(), deleteVariant: jest.fn(), listAttachments: jest.fn(), recordAttachment: jest.fn(), deleteAttachment: jest.fn(),
|
||||
attachmentsStatus: jest.fn(), syncAttachmentManifests: jest.fn(),
|
||||
};
|
||||
jest.mock('../src/services/eventDetails', () => Object.fromEntries(Object.keys(mockDetails).map(k => [k, (...a: unknown[]) => (mockDetails as Record<string, jest.Mock>)[k](...a)])));
|
||||
// The upload step: pretend multer saved the file (or refused it).
|
||||
const mockUpload = { file: null as object | null, error: null as Error | null };
|
||||
jest.mock('../src/controllers/eventController', () => ({
|
||||
receiveAttachment: (req: { file?: object; multerError?: Error }, _res: unknown, next: () => void) => { if (mockUpload.error) req.multerError = mockUpload.error; else if (mockUpload.file) req.file = mockUpload.file; next(); },
|
||||
}));
|
||||
|
||||
import { v2Router } from '../src/v2';
|
||||
import { ServiceError } from '../src/services/errors';
|
||||
import { routes } from '../src/v2/route';
|
||||
@@ -430,3 +442,62 @@ describe('events (staff)', () => {
|
||||
expect((await request(app).delete('/api/v2/events/e1')).body.data).toEqual({ id: 'e1', isActive: false });
|
||||
});
|
||||
});
|
||||
|
||||
describe('one event in full, options, attachments', () => {
|
||||
const detail = {
|
||||
id: 'e1', title: 'Camp', description: null, startDate: '2026-12-04T16:00:00.000Z', endDate: '2026-12-06T12:00:00.000Z', isActive: true, isHidden: false,
|
||||
requiresRegistration: true, scheduleType: 'single', attendanceMode: 'whole', cashupStatus: 'open', campusId: null, seriesId: null, picture: null,
|
||||
eventOptions: [], sessions: [], form: null, attachments: [], bundles: [],
|
||||
};
|
||||
afterEach(() => { mockUpload.file = null; mockUpload.error = null; });
|
||||
|
||||
test('/events/{id}/full asks for the staff view only for staff', async () => {
|
||||
mockDetails.getEventDetail.mockResolvedValue(detail);
|
||||
await request(app).get('/api/v2/events/e1/full');
|
||||
expect(mockDetails.getEventDetail.mock.calls[0][1]).toEqual({ staff: false, scope: null });
|
||||
signedIn = { id: 's1', role: 'staff' };
|
||||
const res = await request(app).get('/api/v2/events/e1/full');
|
||||
expect(res.status).toBe(200);
|
||||
expect(mockDetails.getEventDetail.mock.calls[1][1]).toEqual({ staff: true, scope: null });
|
||||
});
|
||||
|
||||
test('the calendar file is a download, not JSON', async () => {
|
||||
mockDetails.eventCalendar.mockResolvedValue({ filename: 'Camp.ics', ics: 'BEGIN:VCALENDAR\nEND:VCALENDAR' });
|
||||
const res = await request(app).get('/api/v2/events/e1/calendar.ics');
|
||||
expect(res.status).toBe(200);
|
||||
expect(res.headers['content-type']).toContain('text/calendar');
|
||||
expect(res.headers['content-disposition']).toBe('attachment; filename="Camp.ics"');
|
||||
expect(res.text).toContain('BEGIN:VCALENDAR');
|
||||
});
|
||||
|
||||
test('ticket options: supervisors add and change them, only admins remove them', async () => {
|
||||
signedIn = { id: 'v1', role: 'supervisor' };
|
||||
mockDetails.createOption.mockResolvedValue({ id: 'o2', eventId: 'e1', name: 'Child', price: 300, isMainTicket: false, stockLimit: 0, staffPrice: null, sessionMode: 'all' });
|
||||
const made = await request(app).post('/api/v2/events/e1/ticket-options').send({ name: 'Child', price: 300 });
|
||||
expect(made.status).toBe(201);
|
||||
expect((await request(app).post('/api/v2/events/e1/ticket-options').send({ price: 300 })).body.error.fields).toHaveProperty('name');
|
||||
expect((await request(app).delete('/api/v2/ticket-options/o2')).status).toBe(403);
|
||||
signedIn = { id: 'a1', role: 'admin' };
|
||||
mockDetails.deleteOption.mockRejectedValueOnce(new ServiceError(400, 'Cannot delete event option that has registrations'));
|
||||
expect((await request(app).delete('/api/v2/ticket-options/o2')).body.error.message).toBe('Cannot delete event option that has registrations');
|
||||
});
|
||||
|
||||
test('uploading an attachment: the file, or why it was refused', async () => {
|
||||
signedIn = { id: 'v1', role: 'supervisor' };
|
||||
mockUpload.error = new Error('Unsupported file type');
|
||||
const refused = await request(app).post('/api/v2/events/e1/attachments');
|
||||
expect(refused.body.error).toMatchObject({ code: 'VALIDATION_FAILED', fields: { file: 'Unsupported file type' } });
|
||||
mockUpload.error = null;
|
||||
mockUpload.file = { originalname: 'packing.pdf', filename: 'event-file-1.pdf', mimetype: 'application/pdf', size: 1200 };
|
||||
mockDetails.recordAttachment.mockResolvedValue({ id: 'a1', eventId: 'e1', originalName: 'packing.pdf', filename: 'event-file-1.pdf', mimeType: 'application/pdf', size: 1200, url: 'http://x/uploads/event-files/event-file-1.pdf', createdAt: new Date('2026-10-29T10:00:00Z') });
|
||||
const ok = await request(app).post('/api/v2/events/e1/attachments');
|
||||
expect(ok.status).toBe(201);
|
||||
expect(ok.body.data).toMatchObject({ originalName: 'packing.pdf', createdAt: '2026-10-29T10:00:00.000Z' });
|
||||
});
|
||||
|
||||
test('the upload is described as multipart and the calendar as a file', () => {
|
||||
const doc = buildOpenApi({ version: 'test' }) as { paths: Record<string, Record<string, { requestBody?: { content: Record<string, unknown> }; responses: Record<string, { content: Record<string, unknown> }> }>> };
|
||||
expect(Object.keys(doc.paths['/events/{id}/attachments'].post.requestBody!.content)).toEqual(['multipart/form-data']);
|
||||
expect(Object.keys(doc.paths['/events/{id}/calendar.ics'].get.responses['200'].content)).toEqual(['text/calendar']);
|
||||
});
|
||||
});
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
+1291
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user