Files
crosscode-platform/apps/events/backend/src/services/eventDetails.ts
T

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 })) };
}