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:
@@ -42,7 +42,7 @@ async function buildRegister(eventId) {
|
||||
holder: { select: { name: true } },
|
||||
user: { select: { name: true, email: true, phoneNumber: true } },
|
||||
usages: { select: { quantityRedeemed: true, sessionId: true, manual: true } },
|
||||
registrationOption: { select: { registrationId: true, eventOptionId: true, variantId: true, sessionId: true, eventOption: { select: { name: true } }, variant: { select: { name: true } } } },
|
||||
registrationOption: { select: { registrationId: true, eventOptionId: true, variantId: true, sessionId: true, sessionIds: true, eventOption: { select: { name: true } }, variant: { select: { name: true } } } },
|
||||
certificates: { select: { id: true, code: true, issuedAt: true, revokedAt: true, manual: true, emailedAt: true } },
|
||||
},
|
||||
orderBy: { createdAt: 'asc' },
|
||||
@@ -68,9 +68,10 @@ async function buildRegister(eventId) {
|
||||
const cert = t.certificates[0] || null;
|
||||
return {
|
||||
ticketId: t.id,
|
||||
// Picked sessions: which sessions this person booked, and the ticket for each.
|
||||
// Picked or ticked sessions: which sessions this person booked, and the ticket for each
|
||||
// (an all-sessions ticket with sessions ticked is one ticket for all of them).
|
||||
bookedSessions: g.sessionIds,
|
||||
sessionTickets: g.sessionIds ? Object.fromEntries(g.tickets.map(tk => [tk.registrationOption.sessionId, tk.id])) : null,
|
||||
sessionTickets: g.sessionIds ? Object.fromEntries(g.tickets.flatMap(tk => (tk.registrationOption.sessionId ? [[tk.registrationOption.sessionId, tk.id]] : g.sessionIds.map(id => [id, tk.id])))) : null,
|
||||
name: t.attendee?.name || t.holder?.name || t.user?.name || '',
|
||||
bookedBy: t.attendee || t.holder ? t.user?.name || '' : '',
|
||||
email: t.user?.email || '',
|
||||
@@ -117,7 +118,7 @@ const markAttendance = async (req, res) => {
|
||||
const { eventId } = req.params;
|
||||
const { ticketId, present } = req.body || {};
|
||||
const sessionKey = String(req.body?.sessionId || '');
|
||||
const ticket = await prisma.ticket.findUnique({ where: { id: String(ticketId || '') }, include: { usages: true, event: { select: { scheduleType: true, cashupStatus: true } }, registrationOption: { select: { sessionId: true } } } });
|
||||
const ticket = await prisma.ticket.findUnique({ where: { id: String(ticketId || '') }, include: { usages: true, event: { select: { scheduleType: true, cashupStatus: true } }, registrationOption: { select: { sessionId: true, sessionIds: true } } } });
|
||||
if (!ticket || ticket.eventId !== eventId) throw notFound('Ticket not found for this event');
|
||||
if (ticket.event.cashupStatus === 'closed') throw badRequest('This event is closed — reopen it to change attendance.');
|
||||
const multi = ticket.event.scheduleType === 'sessions';
|
||||
@@ -126,7 +127,7 @@ const markAttendance = async (req, res) => {
|
||||
const session = await prisma.eventSession.findUnique({ where: { id: sessionKey } });
|
||||
if (!session || session.eventId !== eventId) throw notFound('Session not found for this event');
|
||||
if (session.cancelledAt) throw badRequest('That session was cancelled');
|
||||
if (ticket.registrationOption?.sessionId && ticket.registrationOption.sessionId !== session.id) throw badRequest('That ticket is for a different session');
|
||||
if (ticket.registrationOption && !require('../utils/sessions').lineCovers(ticket.registrationOption, session.id)) throw badRequest('That ticket isn\'t booked for this session');
|
||||
sessionId = session.id;
|
||||
} else if (sessionKey !== WHOLE_EVENT) {
|
||||
throw badRequest('This event has no sessions');
|
||||
|
||||
@@ -250,8 +250,11 @@ async function basketBuyer(req, forUserId) {
|
||||
/** Prices a basket the same way registration will, as coupon/bundle lines. */
|
||||
async function priceBasket(event, options, buyer) {
|
||||
const registrationOptions = [];
|
||||
// A "pick sessions" line counts once per chosen session.
|
||||
const expanded = (options || []).flatMap(o => (Array.isArray(o.sessionIds) && o.sessionIds.length ? o.sessionIds.map(sessionId => ({ ...o, sessionId })) : [o]));
|
||||
// A "pick sessions" line counts once per chosen session (an all-sessions ticket with
|
||||
// sessions ticked is still one line at one price).
|
||||
const { isPickOption } = require('../utils/sessions');
|
||||
const perSession = (o) => isPickOption(event, event.eventOptions.find(x => x.id === o.eventOptionId));
|
||||
const expanded = (options || []).flatMap(o => (Array.isArray(o.sessionIds) && o.sessionIds.length && perSession(o) ? o.sessionIds.map(sessionId => ({ ...o, sessionId })) : [o]));
|
||||
for (const o of expanded) {
|
||||
const eo = event.eventOptions.find(x => x.id === o.eventOptionId);
|
||||
const qty = Number(o.quantity || 0);
|
||||
|
||||
@@ -53,7 +53,7 @@ const ACTIVE_COUPONS_INCLUDE = {
|
||||
select: { id: true, discountAmount: true, createdAt: true, coupon: { select: { id: true, code: true, type: true, value: true, description: true } } },
|
||||
};
|
||||
const { BUNDLE_APPS_INCLUDE } = require('../utils/bundles');
|
||||
const { registrationClosesAt, wholeCourseClosesAt, expandPickLines, assertSessionCapacity, isPickOption } = require('../utils/sessions');
|
||||
const { registrationClosesAt, wholeCourseClosesAt, expandPickLines, assertSessionCapacity, isPickOption, mergeSessionIds } = require('../utils/sessions');
|
||||
|
||||
/**
|
||||
* Coupon lines for options that haven't been saved yet, so a code can be checked
|
||||
@@ -226,11 +226,12 @@ const createRegistration = async (req, res) => {
|
||||
// "Pick sessions" options become one line per chosen session; whole-course tickets
|
||||
// on such an event still close when the whole course does.
|
||||
const lines = expandPickLines(event, options, { now });
|
||||
if (event.attendanceMode === 'pick' && lines.some(l => !l.sessionId) && now >= wholeCourseClosesAt(event, event.sessions)) {
|
||||
// (An all-sessions ticket with sessions ticked is checked per session instead.)
|
||||
if (event.attendanceMode === 'pick' && lines.some(l => !l.sessionId && !l.sessionIds?.length) && now >= wholeCourseClosesAt(event, event.sessions)) {
|
||||
res.status(400);
|
||||
throw new Error('Whole-course tickets are no longer on sale — choose the sessions you want instead.');
|
||||
}
|
||||
await assertSessionCapacity(event, lines);
|
||||
await assertSessionCapacity(event, lines, undefined, { excludeEntryId: waitlistOffer?.id });
|
||||
|
||||
// Validate each option and resolve prices / check stock.
|
||||
// Options are independent of each other, so resolve them concurrently. Errors are marked
|
||||
@@ -347,7 +348,7 @@ const createRegistration = async (req, res) => {
|
||||
}),
|
||||
prisma.registrationOption.update({
|
||||
where: { id: existing.id },
|
||||
data: { quantity: existing.quantity + opt.quantity, priceSnapshot: opt.priceSnapshot, appliedTierId: opt.appliedTierId || null }
|
||||
data: { quantity: existing.quantity + opt.quantity, priceSnapshot: opt.priceSnapshot, appliedTierId: opt.appliedTierId || null, ...(existing.sessionId ? {} : { sessionIds: mergeSessionIds(existing.sessionIds, opt.sessionIds) }) }
|
||||
})
|
||||
]);
|
||||
} else {
|
||||
@@ -359,6 +360,7 @@ const createRegistration = async (req, res) => {
|
||||
quantity: opt.quantity,
|
||||
variantId: opt.variantId || null,
|
||||
sessionId: opt.sessionId || null,
|
||||
sessionIds: opt.sessionIds || [],
|
||||
appliedTierId: opt.appliedTierId || null,
|
||||
priceSnapshot: opt.priceSnapshot,
|
||||
tranches: {
|
||||
@@ -407,6 +409,7 @@ const createRegistration = async (req, res) => {
|
||||
quantity: option.quantity,
|
||||
variantId: option.variantId || null,
|
||||
sessionId: option.sessionId || null,
|
||||
sessionIds: option.sessionIds || [],
|
||||
appliedTierId: option.appliedTierId || null,
|
||||
priceSnapshot: option.priceSnapshot,
|
||||
tranches: {
|
||||
@@ -1193,6 +1196,8 @@ const createManualRegistration = async (req, res) => {
|
||||
quantity: existing.quantity + opt.quantity,
|
||||
priceSnapshot: opt.priceSnapshot,
|
||||
appliedTierId: opt.appliedTierId || null,
|
||||
// More of an all-sessions ticket: it covers the sessions of both bookings.
|
||||
...(existing.sessionId ? {} : { sessionIds: mergeSessionIds(existing.sessionIds, opt.sessionIds) }),
|
||||
}
|
||||
})
|
||||
]);
|
||||
@@ -1205,6 +1210,7 @@ const createManualRegistration = async (req, res) => {
|
||||
quantity: opt.quantity,
|
||||
variantId: opt.variantId || null,
|
||||
sessionId: opt.sessionId || null,
|
||||
sessionIds: opt.sessionIds || [],
|
||||
appliedTierId: opt.appliedTierId || null,
|
||||
priceSnapshot: opt.priceSnapshot,
|
||||
tranches: {
|
||||
@@ -1274,6 +1280,7 @@ const createManualRegistration = async (req, res) => {
|
||||
quantity: option.quantity,
|
||||
variantId: option.variantId || null,
|
||||
sessionId: option.sessionId || null,
|
||||
sessionIds: option.sessionIds || [],
|
||||
appliedTierId: option.appliedTierId || null,
|
||||
priceSnapshot: option.priceSnapshot,
|
||||
tranches: {
|
||||
|
||||
@@ -264,6 +264,7 @@ const getScanPreview = async (req, res) => {
|
||||
t."eventId",
|
||||
ro.id AS "registrationOptionId",
|
||||
ro."sessionId" AS "pinnedSessionId",
|
||||
ro."sessionIds" AS "chosenSessionIds",
|
||||
eo.id AS "eventOptionId",
|
||||
eo.name AS "eventOptionName",
|
||||
ov.id AS "variantId",
|
||||
@@ -316,7 +317,7 @@ const getScanPreview = async (req, res) => {
|
||||
if (r.scheduleType === 'sessions') {
|
||||
const sessionsUtil = require('../utils/sessions');
|
||||
const schedule = await sessionsUtil.eventSchedule(r.eventId);
|
||||
const found = sessionsUtil.ticketScanSession(schedule, schedule.sessions, r.pinnedSessionId, req.query.sessionId || null);
|
||||
const found = sessionsUtil.ticketScanSession(schedule, schedule.sessions, r.pinnedSessionId, req.query.sessionId || null, new Date(), r.chosenSessionIds);
|
||||
sessionError = found.error;
|
||||
if (found.session) {
|
||||
session = { id: found.session.id, label: sessionsUtil.sessionLabel(found.session, schedule.sessions) };
|
||||
@@ -364,6 +365,7 @@ const scanTicket = async (req, res) => {
|
||||
e.title AS "eventTitle",
|
||||
e."scheduleType" AS "scheduleType",
|
||||
ro."sessionId" AS "pinnedSessionId",
|
||||
ro."sessionIds" AS "chosenSessionIds",
|
||||
eo.id AS "eventOptionId",
|
||||
eo.name AS "eventOptionName",
|
||||
eo."isMainTicket" AS "isMainTicket",
|
||||
@@ -441,7 +443,7 @@ const scanTicket = async (req, res) => {
|
||||
if (r.scheduleType === 'sessions') {
|
||||
sessionsUtil = require('../utils/sessions');
|
||||
schedule = await sessionsUtil.eventSchedule(ticket.eventId);
|
||||
const found = sessionsUtil.ticketScanSession(schedule, schedule.sessions, r.pinnedSessionId, String(req.body?.sessionId || req.query?.sessionId || '').trim() || null);
|
||||
const found = sessionsUtil.ticketScanSession(schedule, schedule.sessions, r.pinnedSessionId, String(req.body?.sessionId || req.query?.sessionId || '').trim() || null, new Date(), r.chosenSessionIds);
|
||||
if (!found.session) return res.status(400).json({ message: found.error, code: 'NO_SESSION', ticket });
|
||||
session = found.session;
|
||||
}
|
||||
@@ -917,7 +919,7 @@ function drawTicketCard(doc, { x, y, w, h }, ticket, qrDataUrl, buyerName) {
|
||||
// Event title, with the date on the right of the same line
|
||||
let cy = y + pad;
|
||||
const eventDate = ticket.event.startDate ? new Date(ticket.event.startDate) : null;
|
||||
const dateStr = require('../utils/sessions').ticketDateText(ticket.event, 'short', ticket.registrationOption.session)
|
||||
const dateStr = require('../utils/sessions').ticketDateText(ticket.event, 'short', ticket.registrationOption.session, null, ticket.registrationOption.sessionIds)
|
||||
|| (eventDate ? new Intl.DateTimeFormat('en-GB', { day: '2-digit', month: 'long', year: 'numeric' }).format(eventDate) : '');
|
||||
doc.font('Helvetica').fontSize(9);
|
||||
const dateW = dateStr ? doc.widthOfString(dateStr) : 0;
|
||||
@@ -1092,7 +1094,10 @@ async function emailTicketsInternal(req, res, userOverride) {
|
||||
|
||||
const eventTitle = tickets[0].event.title;
|
||||
const pinnedSessions = tickets.map(t => t.registrationOption?.session).filter(Boolean);
|
||||
const eventDate = require('../utils/sessions').ticketDateText(tickets[0].event, 'long', pinnedSessions.length === tickets.length && pinnedSessions.length === 1 ? pinnedSessions[0] : null, pinnedSessions.length === tickets.length ? pinnedSessions : null) || (tickets[0].event.startDate
|
||||
// All-sessions tickets with the same sessions ticked: those sessions.
|
||||
const chosenKeys = new Set(tickets.map(t => (t.registrationOption?.sessionIds || []).join(',')));
|
||||
const chosenIds = chosenKeys.size === 1 && !pinnedSessions.length ? tickets[0].registrationOption?.sessionIds : null;
|
||||
const eventDate = require('../utils/sessions').ticketDateText(tickets[0].event, 'long', pinnedSessions.length === tickets.length && pinnedSessions.length === 1 ? pinnedSessions[0] : null, pinnedSessions.length === tickets.length ? pinnedSessions : null, chosenIds) || (tickets[0].event.startDate
|
||||
? new Date(tickets[0].event.startDate).toLocaleDateString('en-GB', { weekday: 'long', day: 'numeric', month: 'long', year: 'numeric' })
|
||||
: '');
|
||||
const pdfFilename = `tickets-${eventTitle.replace(/[^a-z0-9]/gi, '_').toLowerCase()}.pdf`;
|
||||
|
||||
@@ -2,8 +2,8 @@ const prisma = require('../config/db');
|
||||
const { v4: uuidv4 } = require('uuid');
|
||||
const { safeErrorMessage } = require('../utils/errorUtils');
|
||||
const { findAccountByContact } = require('../utils/accountMatch');
|
||||
const { remainingFor } = require('../utils/stock');
|
||||
const { ACTIVE, makeOffer, queueWaitlist, findOfferByToken } = require('../utils/waitlist');
|
||||
const { ACTIVE, makeOffer, queueWaitlist, findOfferByToken, placesFree, lineName } = require('../utils/waitlist');
|
||||
const { activeSessions, isPickOption, sessionLabel } = require('../utils/sessions');
|
||||
|
||||
const fail = (res, error) => res.status(error.statusCode || (res.statusCode === 200 ? 400 : res.statusCode)).json({ message: safeErrorMessage(error) });
|
||||
|
||||
@@ -11,19 +11,21 @@ const ENTRY_INCLUDE = {
|
||||
event: { select: { id: true, title: true, startDate: true, picture: true } },
|
||||
eventOption: { select: { id: true, name: true } },
|
||||
variant: { select: { id: true, name: true } },
|
||||
session: { select: { id: true, label: true, startsAt: true, endsAt: true } },
|
||||
};
|
||||
|
||||
// @desc Join the waitlist for a sold-out option
|
||||
// @route POST /api/waitlist
|
||||
// @access Public (login needed when the event requires it)
|
||||
// Body: { eventId, eventOptionId, variantId?, quantity, guestName?, guestEmail?, guestPhone? }
|
||||
// Body: { eventId, eventOptionId, variantId?, sessionId?, quantity, guestName?, guestEmail?, guestPhone? }
|
||||
// sessionId: required for a "pick sessions" option (one session per entry), not allowed otherwise.
|
||||
const joinWaitlist = async (req, res) => {
|
||||
try {
|
||||
const { eventId, eventOptionId, variantId = null, quantity, guestName, guestEmail, guestPhone } = req.body || {};
|
||||
const { eventId, eventOptionId, variantId = null, sessionId = null, quantity, guestName, guestEmail, guestPhone } = req.body || {};
|
||||
const qty = parseInt(quantity, 10);
|
||||
if (!eventId || !eventOptionId || !(qty >= 1)) { res.status(400); throw new Error('eventId, eventOptionId and a quantity of at least 1 are required'); }
|
||||
|
||||
const event = await prisma.event.findUnique({ where: { id: eventId }, include: { eventOptions: { include: { variants: true } } } });
|
||||
const event = await prisma.event.findUnique({ where: { id: eventId }, include: { eventOptions: { include: { variants: true } }, sessions: true } });
|
||||
if (!event || !event.isActive) { res.status(404); throw new Error('Event not found'); }
|
||||
if (!event.waitlistEnabled) { res.status(400); throw new Error('This event does not have a waitlist.'); }
|
||||
if (event.cashupStatus === 'closed' || new Date(event.endDate) < new Date()) { res.status(400); throw new Error('This event is no longer taking registrations.'); }
|
||||
@@ -32,7 +34,16 @@ const joinWaitlist = async (req, res) => {
|
||||
const variant = variantId ? (option.variants || []).find(v => v.id === variantId) : null;
|
||||
if (variantId && !variant) { res.status(400); throw new Error('Unknown variant for this option'); }
|
||||
|
||||
const free = await remainingFor(option, variant);
|
||||
if (isPickOption(event, option)) {
|
||||
if (!sessionId) { res.status(400); throw new Error(`Choose which session of "${option.name}" you want to wait for.`); }
|
||||
const session = activeSessions(event.sessions).find(s => s.id === sessionId);
|
||||
if (!session) { res.status(400); throw new Error('That session isn\'t available.'); }
|
||||
if (new Date(session.startsAt) <= new Date()) { res.status(400); throw new Error(`${sessionLabel(session, event.sessions)} has already started.`); }
|
||||
} else if (sessionId) {
|
||||
res.status(400); throw new Error(`"${option.name}" covers every session — no session to choose.`);
|
||||
}
|
||||
|
||||
const free = await placesFree(event, option, variant, sessionId);
|
||||
if (free === null || free >= qty) { res.status(400); throw new Error('There are places available — you can register now.'); }
|
||||
|
||||
// Who's joining
|
||||
@@ -47,15 +58,15 @@ const joinWaitlist = async (req, res) => {
|
||||
})).id;
|
||||
}
|
||||
|
||||
const existing = await prisma.waitlistEntry.findFirst({ where: { userId, eventOptionId, variantId, status: { in: ACTIVE } } });
|
||||
const existing = await prisma.waitlistEntry.findFirst({ where: { userId, eventOptionId, variantId, sessionId, status: { in: ACTIVE } } });
|
||||
if (existing) { res.status(409); throw new Error('You\'re already on the waitlist for this.'); }
|
||||
|
||||
const last = await prisma.waitlistEntry.aggregate({ where: { eventId }, _max: { position: true } });
|
||||
const entry = await prisma.waitlistEntry.create({
|
||||
data: { eventId, eventOptionId, variantId, userId, quantity: qty, position: (last._max.position || 0) + 1 },
|
||||
data: { eventId, eventOptionId, variantId, sessionId, userId, quantity: qty, position: (last._max.position || 0) + 1 },
|
||||
include: ENTRY_INCLUDE,
|
||||
});
|
||||
const ahead = await prisma.waitlistEntry.count({ where: { eventId, eventOptionId, variantId, status: 'waiting', position: { lt: entry.position } } });
|
||||
const ahead = await prisma.waitlistEntry.count({ where: { eventId, eventOptionId, variantId, sessionId, status: 'waiting', position: { lt: entry.position } } });
|
||||
res.status(201).json({ ...entry, ahead, message: `You're on the waitlist${ahead ? ` — ${ahead} ahead of you` : ''}. We'll email or WhatsApp you if a place opens up.` });
|
||||
} catch (error) {
|
||||
fail(res, error);
|
||||
@@ -106,11 +117,15 @@ const claimInfo = async (req, res) => {
|
||||
status: expired ? 'expired' : 'offered',
|
||||
eventId: entry.eventId,
|
||||
eventTitle: entry.event.title,
|
||||
eventStart: entry.event.startDate,
|
||||
eventStart: entry.session?.startsAt || entry.event.startDate,
|
||||
eventOptionId: entry.eventOptionId,
|
||||
optionName: entry.eventOption.name,
|
||||
variantId: entry.variantId,
|
||||
variantName: entry.variant?.name || null,
|
||||
sessionId: entry.sessionId,
|
||||
sessionName: entry.session ? sessionLabel(entry.session, entry.event.sessions) : null,
|
||||
sessionStart: entry.session?.startsAt || null,
|
||||
lineName: lineName(entry),
|
||||
quantity: entry.offeredQuantity,
|
||||
requested: entry.quantity,
|
||||
expiresAt: entry.offerExpiresAt,
|
||||
@@ -142,8 +157,11 @@ const eventWaitlist = async (req, res) => {
|
||||
// @access Private/Supervisor
|
||||
const offerManually = async (req, res) => {
|
||||
try {
|
||||
const entry = await prisma.waitlistEntry.findUnique({ where: { id: req.params.id } });
|
||||
const entry = await prisma.waitlistEntry.findUnique({ where: { id: req.params.id }, include: { session: true } });
|
||||
if (!entry) { res.status(404); throw new Error('Waitlist entry not found'); }
|
||||
if (entry.session && (entry.session.cancelledAt || new Date(entry.session.startsAt) <= new Date())) {
|
||||
res.status(400); throw new Error(`The session they're waiting for has ${entry.session.cancelledAt ? 'been cancelled' : 'already started'}.`);
|
||||
}
|
||||
if (!['waiting', 'expired'].includes(entry.status)) { res.status(400); throw new Error(`This person is ${entry.status === 'offered' ? 'already holding an offer' : `no longer waiting (${entry.status})`}.`); }
|
||||
const qty = Math.max(1, Math.min(entry.quantity, parseInt(req.body?.quantity, 10) || entry.quantity));
|
||||
const updated = await makeOffer(entry.id, qty);
|
||||
|
||||
@@ -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