Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Ls1vMdg2GYqbnKZmPaX1ot
374 lines
20 KiB
TypeScript
374 lines
20 KiB
TypeScript
/**
|
|
* 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';
|
|
import { publicBundlesForEvent } from './deals';
|
|
|
|
/* 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 { 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 })) };
|
|
}
|