Session gaps: per-session waitlist, door session picker, all-sessions choice
- Waitlist per session: entries for pick-sessions tickets name a session; offers use that session's free places, never run past its start, and claim links tick it. Held offers count towards session capacity. - At the door: the Select items pop-up has the session picker, with today's session preselected for new attendees. - On pick-sessions events every ticket shows the session list straight away. "All sessions" tickets record the ticked sessions (RegistrationOption.sessionIds) at one price; scanning, attendance, certificates, reminders and capacity follow them. - Fix: per-session stock limits weren't enforced (takenCount filtered WaitlistEntry by a sessionId column that didn't exist, and the error was swallowed), and the public event page lost its stock info. - Fix: editing a door registration with picked sessions couldn't be saved. - Fix: the offline-scanning service worker served /_next/static cache-first forever, so dev browsers that had opened the scanner ran stale code. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -57,7 +57,7 @@ async function attendanceForCertificates(eventId) {
|
||||
holder: { select: { id: true, name: true } },
|
||||
user: { select: { id: true, name: true } },
|
||||
usages: { select: { quantityRedeemed: true, sessionId: true } },
|
||||
registrationOption: { select: { registrationId: true, eventOptionId: true, variantId: true, sessionId: true } },
|
||||
registrationOption: { select: { registrationId: true, eventOptionId: true, variantId: true, sessionId: true, sessionIds: true } },
|
||||
},
|
||||
orderBy: { createdAt: 'asc' },
|
||||
});
|
||||
|
||||
@@ -147,8 +147,8 @@ async function snapshotFor(lock) {
|
||||
session: session ? { id: session.id, label: sessionsUtil.sessionLabel(session, schedule.sessions) } : null,
|
||||
noSessionToday: schedule?.scheduleType === 'sessions' && !session,
|
||||
tickets: tickets.map(t => {
|
||||
// A picked-session ticket for another session has nothing left today.
|
||||
const otherSession = !!(t.registrationOption.sessionId && t.registrationOption.sessionId !== session?.id);
|
||||
// A ticket for other sessions (picked, or ticked on an all-sessions ticket) has nothing left today.
|
||||
const otherSession = !!(session ? !sessionsUtil.lineCovers(t.registrationOption, session.id) : t.registrationOption.sessionId);
|
||||
const redeemed = schedule?.scheduleType === 'sessions'
|
||||
? (session && !otherSession ? sessionsUtil.redeemedForSession(t.usages, session.id) : t.quantity || 1)
|
||||
: t.usages.reduce((s, u) => s + (u.quantityRedeemed || 1), 0);
|
||||
@@ -204,7 +204,7 @@ async function syncScans(lock, scans) {
|
||||
state = {
|
||||
sessionId: session?.id || null,
|
||||
noSession: hasSessions && !session,
|
||||
wrongSession: !!(session && ticket.registrationOption.sessionId && ticket.registrationOption.sessionId !== session.id),
|
||||
wrongSession: !!(session && !sessionsUtil.lineCovers(ticket.registrationOption, session.id)),
|
||||
remaining: (ticket.quantity || 1) - redeemed,
|
||||
cancelled: ticket.registrationOption.registration.status === 'cancelled',
|
||||
inScope: !optionIds || optionIds.has(ticket.registrationOption.eventOptionId),
|
||||
|
||||
@@ -21,10 +21,10 @@ function fmtWhen(d) {
|
||||
return new Date(d).toLocaleString('en-GB', { timeZone: TIMEZONE, weekday: 'long', day: 'numeric', month: 'long', hour: '2-digit', minute: '2-digit' });
|
||||
}
|
||||
|
||||
/** People to remind about a session: whole-course tickets plus picked places on it. Map userId → user. */
|
||||
/** People to remind about a session: whole-course tickets (all sessions, or this one ticked) plus picked places on it. Map userId → user. */
|
||||
async function recipientsFor(eventId, sessionId) {
|
||||
const tickets = await prisma.ticket.findMany({
|
||||
where: { eventId, registrationOption: { registration: { status: { not: 'cancelled' } }, OR: [{ sessionId: null }, { sessionId }] } },
|
||||
where: { eventId, registrationOption: { registration: { status: { not: 'cancelled' } }, OR: [{ sessionId: null, sessionIds: { isEmpty: true } }, { sessionId: null, sessionIds: { has: sessionId } }, { sessionId }] } },
|
||||
select: {
|
||||
user: { select: { id: true, name: true, email: true, phoneNumber: true, notificationPreference: true, isActive: true } },
|
||||
holder: { select: { id: true, name: true, email: true, phoneNumber: true, notificationPreference: true, isActive: true } },
|
||||
|
||||
@@ -17,7 +17,12 @@
|
||||
* bought per session — one registration line (and ticket) per session, priced per
|
||||
* session, bookable until that session starts. `all` options cover every session and
|
||||
* follow the whole-course rules above. A session's capacity counts picked places plus
|
||||
* whole-course main tickets; a pick option's stock limit is places per session.
|
||||
* whole-course main tickets (and places held for waitlist offers); a pick option's stock
|
||||
* limit is places per session. The waitlist for a pick option is per session.
|
||||
* `all` options on such an event also let people tick the sessions they'll come to
|
||||
* (RegistrationOption.sessionIds): one line, one ticket and one price, but the ticket
|
||||
* scans, counts towards capacity and gets reminders for those sessions only. No
|
||||
* sessions ticked = every session (the whole-course rules).
|
||||
* Not available on youth (parental consent) events, and picked lines take no names.
|
||||
*/
|
||||
|
||||
@@ -138,6 +143,11 @@ function registrationClosesAt(event, sessions) {
|
||||
return deadline && deadline < closes ? deadline : closes;
|
||||
}
|
||||
|
||||
/** Whether people choose sessions on this event (attendance mode "pick sessions"). */
|
||||
function choosesSessions(event) {
|
||||
return event?.scheduleType === 'sessions' && event?.attendanceMode === 'pick';
|
||||
}
|
||||
|
||||
/** Whether an option is bought per session (only in "pick sessions" events). */
|
||||
function isPickOption(event, option) {
|
||||
return event?.scheduleType === 'sessions' && event?.attendanceMode === 'pick' && option?.sessionMode === 'pick';
|
||||
@@ -145,68 +155,125 @@ function isPickOption(event, option) {
|
||||
|
||||
/**
|
||||
* Turns requested lines into registration lines: a pick option with sessionIds becomes
|
||||
* one line per session (same quantity); other options stay as they are. Checks the
|
||||
* sessions can still be booked: public — before the session starts; staff — until it ends.
|
||||
* one line per session (same quantity); an all-sessions option on a pick-sessions event
|
||||
* keeps its sessionIds (the sessions ticked, empty = every session) on one line. Checks
|
||||
* the sessions can still be booked: public — before the session starts; staff — until it ends.
|
||||
* @param {object} event - with eventOptions and sessions
|
||||
* @param {object[]} lines - [{ eventOptionId, variantId?, quantity, sessionIds? }]
|
||||
*/
|
||||
function expandPickLines(event, lines, { now = new Date(), staff = false } = {}) {
|
||||
const out = [];
|
||||
const bookable = (option, id) => {
|
||||
const session = (event.sessions || []).find(s => s.id === id);
|
||||
if (!session || session.cancelledAt) throw sessionError(`A chosen session for "${option.name}" isn't available.`);
|
||||
const cutoff = staff ? new Date(session.endsAt) : new Date(session.startsAt);
|
||||
if (cutoff <= now) throw sessionError(`${sessionLabel(session, event.sessions)} has ${staff ? 'ended' : 'already started'} — it can't be booked any more.`);
|
||||
};
|
||||
for (const line of lines || []) {
|
||||
const option = (event.eventOptions || []).find(o => o.id === line.eventOptionId);
|
||||
const pick = isPickOption(event, option);
|
||||
const ids = Array.isArray(line.sessionIds) ? [...new Set(line.sessionIds.map(String))] : [];
|
||||
const { sessionIds, ...rest } = line;
|
||||
void sessionIds;
|
||||
if (!pick) {
|
||||
if (ids.length) throw sessionError(`"${option?.name || 'This ticket'}" covers every session — no sessions to choose.`);
|
||||
out.push({ ...line, sessionId: null });
|
||||
if (ids.length && !choosesSessions(event)) throw sessionError(`"${option?.name || 'This ticket'}" covers every session — no sessions to choose.`);
|
||||
for (const id of ids) bookable(option, id);
|
||||
out.push({ ...rest, sessionId: null, sessionIds: ids });
|
||||
continue;
|
||||
}
|
||||
if (event.requiresParentalConsent) throw sessionError('Choosing sessions isn\'t available on youth events.');
|
||||
if (ids.length === 0) throw sessionError(`Choose the sessions for "${option.name}".`);
|
||||
for (const id of ids) {
|
||||
const session = (event.sessions || []).find(s => s.id === id);
|
||||
if (!session || session.cancelledAt) throw sessionError(`A chosen session for "${option.name}" isn't available.`);
|
||||
const cutoff = staff ? new Date(session.endsAt) : new Date(session.startsAt);
|
||||
if (cutoff <= now) throw sessionError(`${sessionLabel(session, event.sessions)} has ${staff ? 'ended' : 'already started'} — it can't be booked any more.`);
|
||||
const { sessionIds, ...rest } = line;
|
||||
void sessionIds;
|
||||
bookable(option, id);
|
||||
out.push({ ...rest, sessionId: id });
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/**
|
||||
* The sessions a line attends: its picked session, the sessions ticked on an
|
||||
* all-sessions ticket, or null for every session.
|
||||
* @param {{ sessionId?: string|null, sessionIds?: string[] }} line
|
||||
* @returns {string[]|null}
|
||||
*/
|
||||
function lineSessions(line) {
|
||||
if (line?.sessionId) return [line.sessionId];
|
||||
return line?.sessionIds?.length ? line.sessionIds : null;
|
||||
}
|
||||
|
||||
/** Whether a ticket's line covers `sessionId` (picked session, ticked sessions, or every session). */
|
||||
function lineCovers(line, sessionId) {
|
||||
const ids = lineSessions(line);
|
||||
return !ids || ids.includes(sessionId);
|
||||
}
|
||||
|
||||
/** Merges the ticked sessions of two all-sessions lines (empty = every session wins). */
|
||||
function mergeSessionIds(a, b) {
|
||||
if (!a?.length || !b?.length) return [];
|
||||
return [...new Set([...a, ...b])];
|
||||
}
|
||||
|
||||
/**
|
||||
* People booked per session: picked places on that session plus whole-course main
|
||||
* tickets (which attend every session). Cancelled registrations don't count.
|
||||
* tickets (which attend every session). Cancelled registrations don't count; places
|
||||
* held for a live waitlist offer do (except `excludeEntryId`, the offer being claimed).
|
||||
* @returns {Promise<Map<string, number>>}
|
||||
*/
|
||||
async function sessionBookings(eventId, db = prisma) {
|
||||
const lines = await db.registrationOption.findMany({
|
||||
where: { registration: { eventId, status: { not: 'cancelled' } }, eventOption: { isMainTicket: true } },
|
||||
select: { quantity: true, sessionId: true },
|
||||
});
|
||||
async function sessionBookings(eventId, db = prisma, { excludeEntryId = null } = {}) {
|
||||
const [booked, held] = await Promise.all([
|
||||
db.registrationOption.findMany({
|
||||
where: { registration: { eventId, status: { not: 'cancelled' } }, eventOption: { isMainTicket: true } },
|
||||
select: { quantity: true, sessionId: true, sessionIds: true },
|
||||
}),
|
||||
db.waitlistEntry.findMany({
|
||||
where: {
|
||||
eventId, status: 'offered', offerExpiresAt: { gt: new Date() }, eventOption: { isMainTicket: true },
|
||||
...(excludeEntryId ? { id: { not: excludeEntryId } } : {}),
|
||||
},
|
||||
select: { offeredQuantity: true, sessionId: true },
|
||||
}),
|
||||
]);
|
||||
const lines = [...booked, ...held.map(h => ({ quantity: h.offeredQuantity, sessionId: h.sessionId }))];
|
||||
const sessions = await db.eventSession.findMany({ where: { eventId, cancelledAt: null }, select: { id: true } });
|
||||
const whole = lines.filter(l => !l.sessionId).reduce((s, l) => s + (l.quantity || 0), 0);
|
||||
const out = new Map(sessions.map(s => [s.id, whole]));
|
||||
for (const l of lines) if (l.sessionId && out.has(l.sessionId)) out.set(l.sessionId, out.get(l.sessionId) + (l.quantity || 0));
|
||||
const out = new Map(sessions.map(s => [s.id, 0]));
|
||||
for (const l of lines) {
|
||||
for (const id of lineSessions(l) || out.keys()) if (out.has(id)) out.set(id, out.get(id) + (l.quantity || 0));
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/**
|
||||
* Session places free for a main-ticket line: its own session (picked) or, for a
|
||||
* whole-course ticket, the fullest session with a capacity. Pure.
|
||||
* @param {object[]} sessions - the event's sessions (with capacity)
|
||||
* @param {Map<string, number>} booked - from sessionBookings
|
||||
* @param {string|null} sessionId - the picked session, or null for whole-course
|
||||
* @returns {number|null} null when no session limits it
|
||||
*/
|
||||
function sessionPlacesFree(sessions, booked, sessionId = null) {
|
||||
const limited = activeSessions(sessions).filter(s => s.capacity > 0 && (!sessionId || s.id === sessionId));
|
||||
if (limited.length === 0) return null;
|
||||
return Math.max(0, Math.min(...limited.map(s => s.capacity - (booked.get(s.id) || 0))));
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks requested lines fit each session's capacity. Whole-course main tickets count
|
||||
* against every session; picked main tickets against their own.
|
||||
* @param {{ excludeEntryId?: string }} [opts] - the waitlist offer being claimed
|
||||
*/
|
||||
async function assertSessionCapacity(event, lines, db = prisma) {
|
||||
async function assertSessionCapacity(event, lines, db = prisma, { excludeEntryId = null } = {}) {
|
||||
const limited = activeSessions(event.sessions).filter(s => s.capacity > 0);
|
||||
if (limited.length === 0) return;
|
||||
const mains = new Set((event.eventOptions || []).filter(o => o.isMainTicket).map(o => o.id));
|
||||
const wanted = new Map();
|
||||
const whole = lines.filter(l => !l.sessionId && mains.has(l.eventOptionId)).reduce((s, l) => s + (Number(l.quantity) || 0), 0);
|
||||
for (const s of limited) wanted.set(s.id, whole);
|
||||
for (const l of lines) if (l.sessionId && mains.has(l.eventOptionId) && wanted.has(l.sessionId)) wanted.set(l.sessionId, wanted.get(l.sessionId) + (Number(l.quantity) || 0));
|
||||
for (const s of limited) wanted.set(s.id, 0);
|
||||
for (const l of lines) {
|
||||
if (!mains.has(l.eventOptionId)) continue;
|
||||
for (const id of lineSessions(l) || wanted.keys()) if (wanted.has(id)) wanted.set(id, wanted.get(id) + (Number(l.quantity) || 0));
|
||||
}
|
||||
if ([...wanted.values()].every(n => n === 0)) return;
|
||||
const booked = await sessionBookings(event.id, db);
|
||||
const booked = await sessionBookings(event.id, db, { excludeEntryId });
|
||||
for (const s of limited) {
|
||||
const left = s.capacity - (booked.get(s.id) || 0);
|
||||
if ((wanted.get(s.id) || 0) > left) {
|
||||
@@ -384,9 +451,17 @@ function scanSession(event, sessions, requestedId = null, now = new Date()) {
|
||||
* (short) or "Wednesday 4 November 2026 (first of 5 sessions — one ticket for all)" (long).
|
||||
* Returns null for single-date events (callers keep their own date format).
|
||||
*/
|
||||
function ticketDateText(event, style = 'short', session = null, sessions = null) {
|
||||
function ticketDateText(event, style = 'short', session = null, sessions = null, chosenIds = null) {
|
||||
if (event?.scheduleType !== 'sessions') return null;
|
||||
const fmt = (d, opts) => new Date(d).toLocaleDateString('en-GB', { timeZone: TIMEZONE, ...opts });
|
||||
// An all-sessions ticket with sessions ticked: those sessions.
|
||||
const chosen = chosenIds?.length ? activeSessions(event.sessions).filter(s => chosenIds.includes(s.id)) : [];
|
||||
if (!session && chosen.length === 1) session = chosen[0];
|
||||
else if (!session && chosen.length > 1) {
|
||||
return style === 'long'
|
||||
? `${chosen.map(s => fmt(s.startsAt, { weekday: 'short', day: 'numeric', month: 'short' })).join(', ')} (${chosen.length} sessions — one ticket for all)`
|
||||
: `${chosen.length} sessions · ${chosen.map(s => fmt(s.startsAt, { day: '2-digit', month: 'short' })).join(', ')}`;
|
||||
}
|
||||
// A picked-session ticket is for its own session only.
|
||||
if (session) {
|
||||
const label = sessionLabel(session, event.sessions);
|
||||
@@ -412,9 +487,18 @@ function ticketDateText(event, style = 'short', session = null, sessions = null)
|
||||
|
||||
/**
|
||||
* scanSession for a ticket: a picked-session ticket only checks in on its own session
|
||||
* (whatever the scanner has selected).
|
||||
* (whatever the scanner has selected); an all-sessions ticket with sessions ticked
|
||||
* (`chosenIds`) only on those.
|
||||
*/
|
||||
function ticketScanSession(event, sessions, pinnedSessionId, requestedId = null, now = new Date()) {
|
||||
function ticketScanSession(event, sessions, pinnedSessionId, requestedId = null, now = new Date(), chosenIds = null) {
|
||||
if (!pinnedSessionId && chosenIds?.length) {
|
||||
const found = scanSession(event, sessions, requestedId, now);
|
||||
if (!found.session || chosenIds.includes(found.session.id)) return found;
|
||||
// Another of their sessions may be open today (a day with more than one session).
|
||||
const own = requestedId ? null : currentSession(activeSessions(sessions).filter(s => chosenIds.includes(s.id)), now, event.checkInWindow || 'whole_day');
|
||||
if (own) return { session: own, error: null };
|
||||
return { session: null, error: `This ticket isn't booked for ${sessionLabel(found.session, sessions)} (${dayKey(found.session.startsAt)})` };
|
||||
}
|
||||
if (!pinnedSessionId) return scanSession(event, sessions, requestedId, now);
|
||||
const pinned = (sessions || []).find(s => s.id === pinnedSessionId);
|
||||
if (!pinned) return { session: null, error: 'This ticket\'s session no longer exists' };
|
||||
@@ -430,7 +514,8 @@ function ticketScanSession(event, sessions, pinnedSessionId, requestedId = null,
|
||||
* Groups an event's tickets into people for the register and certificates: a
|
||||
* picked-session booking has one ticket per session, so its tickets (same registration,
|
||||
* option and variant) form one group. Every other ticket is its own group.
|
||||
* Each ticket needs registrationOption: { registrationId, eventOptionId, variantId, sessionId }.
|
||||
* Each ticket needs registrationOption: { registrationId, eventOptionId, variantId, sessionId, sessionIds }.
|
||||
* An all-sessions ticket with sessions ticked is its own group, limited to those sessions.
|
||||
* @returns {{ key: string, tickets: object[], sessionIds: string[]|null }[]} sessionIds null = all sessions
|
||||
*/
|
||||
function groupTickets(tickets) {
|
||||
@@ -438,7 +523,7 @@ function groupTickets(tickets) {
|
||||
for (const t of tickets) {
|
||||
const ro = t.registrationOption || {};
|
||||
if (!ro.sessionId) {
|
||||
groups.set(t.id, { key: t.id, tickets: [t], sessionIds: null });
|
||||
groups.set(t.id, { key: t.id, tickets: [t], sessionIds: ro.sessionIds?.length ? [...ro.sessionIds] : null });
|
||||
continue;
|
||||
}
|
||||
const key = `pick:${ro.registrationId}:${ro.eventOptionId}:${ro.variantId || ''}`;
|
||||
@@ -487,7 +572,7 @@ module.exports = {
|
||||
TIMEZONE, MAX_SESSIONS, REMINDER_OFFSETS, CERTIFICATE_TEMPLATES, sessionError,
|
||||
dayKey, activeSessions, scheduleBounds, normalizeSessionsInput, sessionAcceptsCheckIn, currentSession,
|
||||
sessionLabel, scanSession, ticketScanSession, redeemedForSession, ticketDateText, groupTickets,
|
||||
registrationClosesAt, wholeCourseClosesAt, isPickOption, expandPickLines, sessionBookings, assertSessionCapacity,
|
||||
registrationClosesAt, wholeCourseClosesAt, choosesSessions, isPickOption, expandPickLines, lineSessions, lineCovers, mergeSessionIds, sessionBookings, sessionPlacesFree, assertSessionCapacity,
|
||||
lateInfo, latePrice, completionMet, normalizeReminders, normalizeCertificateConfig,
|
||||
syncEventSessions, eventSchedule, forgetSchedule, withLatePrice, attendanceBySession,
|
||||
};
|
||||
|
||||
@@ -37,15 +37,17 @@ async function takenCount({ eventOptionId, variantId = null, sessionId = null },
|
||||
|
||||
/**
|
||||
* Places still free on a line: the tighter of the option and variant limits.
|
||||
* @param {{ sessionId?: string|null, excludeEntryId?: string, db?: object }} [opts] -
|
||||
* sessionId: a "pick sessions" line (the limits are places per session)
|
||||
* @returns {Promise<number|null>} null when unlimited
|
||||
*/
|
||||
async function remainingFor(option, variant, opts = {}) {
|
||||
async function remainingFor(option, variant, { sessionId = null, ...opts } = {}) {
|
||||
const limits = [];
|
||||
if (option?.stockLimit > 0) {
|
||||
limits.push(option.stockLimit - await takenCount({ eventOptionId: option.id }, opts));
|
||||
limits.push(option.stockLimit - await takenCount({ eventOptionId: option.id, sessionId }, opts));
|
||||
}
|
||||
if (variant?.stockLimit > 0) {
|
||||
limits.push(variant.stockLimit - await takenCount({ eventOptionId: option.id, variantId: variant.id }, opts));
|
||||
limits.push(variant.stockLimit - await takenCount({ eventOptionId: option.id, variantId: variant.id, sessionId }, opts));
|
||||
}
|
||||
if (limits.length === 0) return null;
|
||||
return Math.max(0, Math.min(...limits));
|
||||
|
||||
@@ -11,11 +11,16 @@
|
||||
* offered what's free; otherwise they're skipped for the next person who fits.
|
||||
* - Claiming = registering with the link (createRegistration's waitlistToken). Early-bird
|
||||
* and coupon rules apply as usual. An unclaimed offer expires and moves on.
|
||||
* - "Pick sessions" options are waited for per session (entry.sessionId): free places are
|
||||
* that session's, an offer never runs past the session's start, and nobody is offered a
|
||||
* session that has started or was cancelled. Main tickets also need room in the
|
||||
* session(s) they cover when sessions have a capacity (utils/sessions.js).
|
||||
*/
|
||||
|
||||
const crypto = require('crypto');
|
||||
const prisma = require('../config/db');
|
||||
const { remainingFor } = require('./stock');
|
||||
const { activeSessions, isPickOption, sessionBookings, sessionPlacesFree, sessionLabel, wholeCourseClosesAt } = require('./sessions');
|
||||
|
||||
const ACTIVE = ['waiting', 'offered'];
|
||||
|
||||
@@ -27,6 +32,42 @@ function waitlistError(message, statusCode = 400) {
|
||||
|
||||
const hashToken = (token) => crypto.createHmac('sha256', process.env.JWT_SECRET || '').update(`waitlist:${token}`).digest('hex');
|
||||
|
||||
/**
|
||||
* Places free on a waitlist line: option/variant stock (per session for a picked line)
|
||||
* and, for main tickets on events with session capacities, room in the session(s).
|
||||
* @param {object} event - with sessions
|
||||
* @returns {Promise<number|null>} null when unlimited
|
||||
*/
|
||||
async function placesFree(event, option, variant, sessionId = null, { db = prisma, excludeEntryId = null } = {}) {
|
||||
const limits = [await remainingFor(option, variant, { sessionId, db, excludeEntryId })];
|
||||
if (event.scheduleType === 'sessions' && option.isMainTicket && (event.sessions || []).some(s => s.capacity > 0)) {
|
||||
limits.push(sessionPlacesFree(event.sessions, await sessionBookings(event.id, db, { excludeEntryId }), sessionId));
|
||||
}
|
||||
const known = limits.filter(n => n !== null);
|
||||
return known.length ? Math.min(...known) : null;
|
||||
}
|
||||
|
||||
/** Whether a waitlist line can still be offered at `now` (its session hasn't started, etc.). */
|
||||
function lineOpen(event, sessionId, now = new Date()) {
|
||||
if (!sessionId) return event.scheduleType !== 'sessions' || now < wholeCourseClosesAt(event, event.sessions);
|
||||
const session = activeSessions(event.sessions).find(s => s.id === sessionId);
|
||||
return !!session && new Date(session.startsAt) > now;
|
||||
}
|
||||
|
||||
/** When an offer made now lapses: the event's offer hours, but never after its session starts. */
|
||||
function offerExpiry(hours, session = null, now = new Date()) {
|
||||
const expires = new Date(now.getTime() + (hours || 24) * 60 * 60 * 1000);
|
||||
return session && new Date(session.startsAt) < expires ? new Date(session.startsAt) : expires;
|
||||
}
|
||||
|
||||
/** "Drop-in (Large)" or "Drop-in — Class 2, Wed 4 Nov" for messages. */
|
||||
function lineName(entry, sessions = entry.event?.sessions) {
|
||||
const base = `${entry.eventOption.name}${entry.variant ? ` (${entry.variant.name})` : ''}`;
|
||||
if (!entry.session) return base;
|
||||
const when = new Date(entry.session.startsAt).toLocaleDateString('en-GB', { timeZone: process.env.APP_TIMEZONE || 'Africa/Johannesburg', weekday: 'short', day: 'numeric', month: 'short' });
|
||||
return `${base} — ${sessionLabel(entry.session, sessions || [entry.session])}, ${when}`;
|
||||
}
|
||||
|
||||
function claimLink(token) {
|
||||
const base = (process.env.FRONTEND_URL || process.env.APP_BASE_URL || 'http://localhost:3001').split(',')[0].trim().replace(/\/$/, '');
|
||||
return `${base}/waitlist/claim/${token}`;
|
||||
@@ -63,7 +104,7 @@ async function notifyOffer(entry, token) {
|
||||
const ff = `-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Helvetica,Arial,sans-serif`;
|
||||
const user = entry.user;
|
||||
const link = claimLink(token);
|
||||
const item = `${entry.eventOption.name}${entry.variant ? ` (${entry.variant.name})` : ''}`;
|
||||
const item = lineName(entry);
|
||||
const until = new Date(entry.offerExpiresAt).toLocaleString('en-GB', { day: 'numeric', month: 'long', hour: '2-digit', minute: '2-digit' });
|
||||
const partialNote = entry.offeredQuantity < entry.quantity
|
||||
? ` You asked for ${entry.quantity}; ${entry.offeredQuantity} came free, and you can take those now.` : '';
|
||||
@@ -86,10 +127,10 @@ async function notifyOffer(entry, token) {
|
||||
await Promise.allSettled(sends);
|
||||
}
|
||||
|
||||
const OFFER_INCLUDE = { event: true, eventOption: true, variant: true, user: { select: { id: true, name: true, email: true, phoneNumber: true, notificationPreference: true } } };
|
||||
const OFFER_INCLUDE = { event: { include: { sessions: true } }, eventOption: true, variant: true, session: true, user: { select: { id: true, name: true, email: true, phoneNumber: true, notificationPreference: true } } };
|
||||
|
||||
/** Puts an entry on offer (inside the caller's transaction); returns the raw token. */
|
||||
async function writeOffer(db, entry, quantity, hours) {
|
||||
/** Puts an entry on offer until `expiresAt` (inside the caller's transaction); returns the raw token. */
|
||||
async function writeOffer(db, entry, quantity, expiresAt) {
|
||||
const token = crypto.randomBytes(24).toString('hex');
|
||||
await db.waitlistEntry.update({
|
||||
where: { id: entry.id },
|
||||
@@ -98,7 +139,7 @@ async function writeOffer(db, entry, quantity, hours) {
|
||||
offeredQuantity: quantity,
|
||||
offerTokenHash: hashToken(token),
|
||||
offeredAt: new Date(),
|
||||
offerExpiresAt: new Date(Date.now() + (hours || 24) * 60 * 60 * 1000),
|
||||
offerExpiresAt: expiresAt,
|
||||
},
|
||||
});
|
||||
return token;
|
||||
@@ -113,8 +154,8 @@ async function notifyOffers(offers) {
|
||||
|
||||
/** Offers `quantity` places to one entry (e.g. a supervisor's manual offer) and notifies. */
|
||||
async function makeOffer(entryId, quantity) {
|
||||
const entry = await prisma.waitlistEntry.findUnique({ where: { id: entryId }, include: { event: true } });
|
||||
const token = await writeOffer(prisma, entry, quantity, entry.event.waitlistOfferHours);
|
||||
const entry = await prisma.waitlistEntry.findUnique({ where: { id: entryId }, include: { event: true, session: true } });
|
||||
const token = await writeOffer(prisma, entry, quantity, offerExpiry(entry.event.waitlistOfferHours, entry.session));
|
||||
await notifyOffers([{ entryId, token }]);
|
||||
return prisma.waitlistEntry.findUnique({ where: { id: entryId } });
|
||||
}
|
||||
@@ -127,7 +168,7 @@ async function makeOffer(entryId, quantity) {
|
||||
async function processWaitlist(eventId) {
|
||||
const event = await prisma.event.findUnique({
|
||||
where: { id: eventId },
|
||||
include: { eventOptions: { include: { variants: true } } },
|
||||
include: { eventOptions: { include: { variants: true } }, sessions: true },
|
||||
});
|
||||
if (!event || !event.waitlistEnabled || !event.isActive || event.cashupStatus === 'closed') return 0;
|
||||
if (new Date(event.endDate) < new Date()) return 0;
|
||||
@@ -136,16 +177,20 @@ async function processWaitlist(eventId) {
|
||||
await prisma.$transaction(async (tx) => {
|
||||
await tx.$executeRaw`SELECT pg_advisory_xact_lock(hashtext(${'waitlist:' + eventId}))`;
|
||||
const waiting = await tx.waitlistEntry.findMany({ where: { eventId, status: 'waiting' }, orderBy: { position: 'asc' } });
|
||||
const lines = [...new Map(waiting.map(w => [`${w.eventOptionId}::${w.variantId || ''}`, w])).values()];
|
||||
const lineKey = (w) => `${w.eventOptionId}::${w.variantId || ''}::${w.sessionId || ''}`;
|
||||
const lines = [...new Map(waiting.map(w => [lineKey(w), w])).values()];
|
||||
for (const sample of lines) {
|
||||
const option = event.eventOptions.find(o => o.id === sample.eventOptionId);
|
||||
const variant = sample.variantId ? (option?.variants || []).find(v => v.id === sample.variantId) : null;
|
||||
if (!option) continue;
|
||||
const free = await remainingFor(option, variant, { db: tx });
|
||||
if (!option || !lineOpen(event, sample.sessionId)) continue;
|
||||
// An option switched between per-session and whole-course after people joined.
|
||||
if (!!sample.sessionId !== isPickOption(event, option)) continue;
|
||||
const free = await placesFree(event, option, variant, sample.sessionId, { db: tx });
|
||||
if (free === null || free <= 0) continue;
|
||||
const queue = waiting.filter(w => w.eventOptionId === sample.eventOptionId && (w.variantId || null) === (sample.variantId || null));
|
||||
const session = sample.sessionId ? event.sessions.find(s => s.id === sample.sessionId) : null;
|
||||
const queue = waiting.filter(w => lineKey(w) === lineKey(sample));
|
||||
for (const offer of pickOffers(queue, free, event.waitlistPartialOffers)) {
|
||||
const token = await writeOffer(tx, { id: offer.entryId }, offer.quantity, event.waitlistOfferHours);
|
||||
const token = await writeOffer(tx, { id: offer.entryId }, offer.quantity, offerExpiry(event.waitlistOfferHours, session));
|
||||
made.push({ entryId: offer.entryId, token });
|
||||
}
|
||||
}
|
||||
@@ -183,7 +228,7 @@ async function findOfferByToken(token) {
|
||||
if (!token || typeof token !== 'string' || token.length > 100) return null;
|
||||
return prisma.waitlistEntry.findUnique({
|
||||
where: { offerTokenHash: hashToken(token) },
|
||||
include: { event: true, eventOption: true, variant: true, user: { select: { id: true, name: true } } },
|
||||
include: { event: { include: { sessions: true } }, eventOption: true, variant: true, session: true, user: { select: { id: true, name: true } } },
|
||||
});
|
||||
}
|
||||
|
||||
@@ -192,6 +237,10 @@ module.exports = {
|
||||
waitlistError,
|
||||
hashToken,
|
||||
pickOffers,
|
||||
placesFree,
|
||||
lineOpen,
|
||||
offerExpiry,
|
||||
lineName,
|
||||
makeOffer,
|
||||
processWaitlist,
|
||||
expireOffers,
|
||||
|
||||
Reference in New Issue
Block a user