WIP 1.51.8: sections, costs and uploads on v2

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Ls1vMdg2GYqbnKZmPaX1ot
This commit is contained in:
2026-10-29 12:08:03 +02:00
co-authored by Claude Opus 5.5
parent 006c4db02f
commit 96b9b8c23f
9 changed files with 3055 additions and 314 deletions
@@ -1,177 +1,44 @@
const prisma = require('../config/db');
const { v4: uuidv4 } = require('uuid');
// Planned event costs (cashup and the profit report). Shared with /api/v2 (services/setup.ts, 1.51.8).
const setup = require('../services/setup');
const { safeErrorMessage } = require('../utils/errorUtils');
const { assertEventOpen, ALL_METHODS } = require('../utils/cashupUtils');
function normalizePaidFromMethod(value) {
if (value === undefined) return undefined;
if (value === null || value === '') return null;
if (!ALL_METHODS.includes(value)) {
throw new Error("paidFromMethod must be one of 'cash', 'card', 'eft', 'other', or null");
}
return value;
}
const fail = (res, error) => res.status(error.statusCode || 400).json({ message: safeErrorMessage(error) });
// @desc List costs for an event
// @route GET /api/events/:eventId/costs
// @access Private/Supervisor
const getEventCosts = async (req, res) => {
try {
const costs = await prisma.eventCost.findMany({
where: { eventId: req.params.eventId },
include: { eventOption: { select: { id: true, name: true } } },
orderBy: { createdAt: 'asc' }
});
res.json(costs);
} catch (error) {
res.status(res.statusCode === 200 ? 400 : res.statusCode).json({ message: safeErrorMessage(error) });
}
res.json(await setup.listCosts(req.params.eventId));
} catch (error) { fail(res, error); }
};
// @desc Create a cost for an event
// @route POST /api/events/:eventId/costs
// @access Private/Supervisor
// @access Private/Admin
const createEventCost = async (req, res) => {
try {
const { eventId } = req.params;
const { label, costType, amount, eventOptionId, notes, paidFromMethod } = req.body;
await assertEventOpen(eventId, res);
if (!label || !String(label).trim()) {
res.status(400);
throw new Error('Label is required');
}
if (costType !== 'once_off' && costType !== 'per_item') {
res.status(400);
throw new Error("costType must be 'once_off' or 'per_item'");
}
const amt = parseFloat(amount);
if (!(amt >= 0)) {
res.status(400);
throw new Error('Amount must be a non-negative number');
}
if (costType === 'per_item' && !eventOptionId) {
res.status(400);
throw new Error('eventOptionId is required for per-item costs');
}
if (costType === 'per_item') {
const option = await prisma.eventOption.findUnique({ where: { id: eventOptionId } });
if (!option || option.eventId !== eventId) {
res.status(404);
throw new Error('Ticket type not found for this event');
}
}
const cost = await prisma.eventCost.create({
data: {
id: uuidv4(),
eventId,
label: String(label).trim(),
costType,
amount: amt,
eventOptionId: costType === 'per_item' ? eventOptionId : null,
paidFromMethod: normalizePaidFromMethod(paidFromMethod) ?? null,
notes: notes || null
},
include: { eventOption: { select: { id: true, name: true } } }
});
res.status(201).json(cost);
} catch (error) {
res.status(res.statusCode === 200 ? 400 : res.statusCode).json({ message: safeErrorMessage(error) });
}
res.status(201).json(await setup.createCost(req.params.eventId, req.body || {}));
} catch (error) { fail(res, error); }
};
// @desc Update a cost
// @route PUT /api/costs/:id
// @access Private/Supervisor
// @access Private/Admin
const updateEventCost = async (req, res) => {
try {
const existing = await prisma.eventCost.findUnique({ where: { id: req.params.id } });
if (!existing) {
res.status(404);
throw new Error('Cost not found');
}
await assertEventOpen(existing.eventId, res);
const { label, costType, amount, eventOptionId, notes, paidFromMethod } = req.body;
const nextCostType = costType !== undefined ? costType : existing.costType;
if (nextCostType !== 'once_off' && nextCostType !== 'per_item') {
res.status(400);
throw new Error("costType must be 'once_off' or 'per_item'");
}
const nextEventOptionId = nextCostType === 'per_item'
? (eventOptionId !== undefined ? eventOptionId : existing.eventOptionId)
: null;
if (nextCostType === 'per_item') {
if (!nextEventOptionId) {
res.status(400);
throw new Error('eventOptionId is required for per-item costs');
}
const option = await prisma.eventOption.findUnique({ where: { id: nextEventOptionId } });
if (!option || option.eventId !== existing.eventId) {
res.status(404);
throw new Error('Ticket type not found for this event');
}
}
let nextAmount = existing.amount;
if (amount !== undefined) {
const amt = parseFloat(amount);
if (!(amt >= 0)) {
res.status(400);
throw new Error('Amount must be a non-negative number');
}
nextAmount = amt;
}
const nextPaidFromMethod = normalizePaidFromMethod(paidFromMethod);
const cost = await prisma.eventCost.update({
where: { id: req.params.id },
data: {
label: label !== undefined ? String(label).trim() : existing.label,
costType: nextCostType,
amount: nextAmount,
eventOptionId: nextEventOptionId,
paidFromMethod: nextPaidFromMethod !== undefined ? nextPaidFromMethod : existing.paidFromMethod,
notes: notes !== undefined ? notes : existing.notes
},
include: { eventOption: { select: { id: true, name: true } } }
});
res.json(cost);
} catch (error) {
res.status(res.statusCode === 200 ? 400 : res.statusCode).json({ message: safeErrorMessage(error) });
}
res.json(await setup.updateCost(req.params.id, req.body || {}));
} catch (error) { fail(res, error); }
};
// @desc Delete a cost
// @route DELETE /api/costs/:id
// @access Private/Supervisor
// @access Private/Admin
const deleteEventCost = async (req, res) => {
try {
const existing = await prisma.eventCost.findUnique({ where: { id: req.params.id } });
if (!existing) {
res.status(404);
throw new Error('Cost not found');
}
await assertEventOpen(existing.eventId, res);
await prisma.eventCost.delete({ where: { id: req.params.id } });
await setup.deleteCost(req.params.id);
res.json({ message: 'Cost deleted' });
} catch (error) {
res.status(res.statusCode === 200 ? 400 : res.statusCode).json({ message: safeErrorMessage(error) });
}
} catch (error) { fail(res, error); }
};
module.exports = {
getEventCosts,
createEventCost,
updateEventCost,
deleteEventCost
};
module.exports = { getEventCosts, createEventCost, updateEventCost, deleteEventCost };
@@ -1,189 +1,45 @@
const prisma = require('../config/db');
const { v4: uuidv4 } = require('uuid');
// Scanning sections: which ticket types may come in at which door. Shared with
// /api/v2/sections (services/setup.ts, 1.51.8).
const setup = require('../services/setup');
const { listWhere } = require('../utils/campusScope');
const fail = (res, error) => res.status(error.statusCode || 400).json({ message: error.message });
//
// @desc Get sections (optionally by event)
// @route GET /api/sections?eventId=xxx
// @access Private/Staff
//
const getSections = async (req, res) => {
try {
const { eventId } = req.query;
const { withScope, listWhere } = require('../utils/campusScope');
const where = withScope(eventId && eventId !== 'all' ? { eventId } : {}, await listWhere(req, 'event'));
const sections = await prisma.section.findMany({
where,
include: {
allowedOptions: {
include: {
eventOption: true
}
},
event: {
select: { id: true, title: true }
}
},
orderBy: { name: 'asc' }
});
res.json(sections);
} catch (error) {
res.status(400).json({ message: error.message });
}
try {
res.json(await setup.listSections(req.query.eventId, await listWhere(req, 'event')));
} catch (error) { fail(res, error); }
};
//
// @desc Create section
// @route POST /api/sections
// @access Private/Admin/Supervisor
//
const createSection = async (req, res) => {
try {
const { eventId, name, allowedOptionIds } = req.body;
if (!eventId || !name) {
res.status(400);
throw new Error('Event and section name are required');
}
const event = await prisma.event.findUnique({
where: { id: eventId }
});
if (!event) {
res.status(404);
throw new Error('Event not found');
}
const section = await prisma.section.create({
data: {
id: uuidv4(),
eventId,
name,
updatedAt: new Date()
}
});
// Attach allowed options if provided
if (Array.isArray(allowedOptionIds) && allowedOptionIds.length > 0) {
await prisma.sectionOption.createMany({
data: allowedOptionIds.map(optionId => ({
id: uuidv4(),
sectionId: section.id,
eventOptionId: optionId
})),
skipDuplicates: true
});
}
const fullSection = await prisma.section.findUnique({
where: { id: section.id },
include: {
allowedOptions: {
include: { eventOption: true }
}
}
});
res.status(201).json(fullSection);
} catch (error) {
res.status(400).json({ message: error.message });
}
try {
res.status(201).json(await setup.createSection(req.body || {}));
} catch (error) { fail(res, error); }
};
//
// @desc Update section
// @route PUT /api/sections/:id
// @access Private/Admin/Supervisor
//
const updateSection = async (req, res) => {
try {
const { name, allowedOptionIds } = req.body;
const section = await prisma.section.findUnique({
where: { id: req.params.id }
});
if (!section) {
res.status(404);
throw new Error('Section not found');
}
const updatedSection = await prisma.section.update({
where: { id: req.params.id },
data: {
name: name || section.name,
updatedAt: new Date()
}
});
// If allowed options supplied → reset them
if (Array.isArray(allowedOptionIds)) {
await prisma.sectionOption.deleteMany({
where: { sectionId: section.id }
});
if (allowedOptionIds.length > 0) {
await prisma.sectionOption.createMany({
data: allowedOptionIds.map(optionId => ({
id: uuidv4(),
sectionId: section.id,
eventOptionId: optionId
}))
});
}
}
const fullSection = await prisma.section.findUnique({
where: { id: section.id },
include: {
allowedOptions: {
include: { eventOption: true }
}
}
});
res.json(fullSection);
} catch (error) {
res.status(400).json({ message: error.message });
}
try {
res.json(await setup.updateSection(req.params.id, req.body || {}));
} catch (error) { fail(res, error); }
};
//
// @desc Delete section
// @route DELETE /api/sections/:id
// @access Private/Admin
//
const deleteSection = async (req, res) => {
try {
const section = await prisma.section.findUnique({
where: { id: req.params.id }
});
if (!section) {
res.status(404);
throw new Error('Section not found');
}
await prisma.section.delete({
where: { id: section.id }
});
res.json({ message: 'Section deleted' });
} catch (error) {
res.status(400).json({ message: error.message });
}
try {
await setup.deleteSection(req.params.id);
res.json({ message: 'Section deleted' });
} catch (error) { fail(res, error); }
};
module.exports = {
getSections,
createSection,
updateSection,
deleteSection
};
module.exports = { getSections, createSection, updateSection, deleteSection };
+140
View File
@@ -0,0 +1,140 @@
/**
* Scanning sections and planned event costs (1.51.8). Moved from sectionController.js and
* costController.js so v1 and /api/v2 share them.
*/
import { v4 as uuidv4 } from 'uuid';
import { prisma } from '../v2/legacy';
import { fail } from './errors';
/* eslint-disable @typescript-eslint/no-explicit-any -- the JS helpers below aren't typed yet */
const cashup = require('../utils/cashupUtils') as { assertEventOpen(eventId: string): Promise<unknown>; ALL_METHODS: string[] };
const openEvent = async (eventId: string) => {
try {
await cashup.assertEventOpen(eventId);
} catch (e: any) {
fail(e.message === 'Event not found' ? 404 : 400, e.message);
}
};
// ─── Sections (which ticket types may come in at which door) ─────────────────
const SECTION_INCLUDE = { allowedOptions: { include: { eventOption: true } } } as const;
/** Sections, for one event or every event the caller may see (`scopeWhere` from campus scope). */
export function listSections(eventId: string | undefined, scopeWhere: object) {
const where = { AND: [eventId && eventId !== 'all' ? { eventId } : {}, scopeWhere] };
return prisma.section.findMany({ where, include: { ...SECTION_INCLUDE, event: { select: { id: true, title: true } } }, orderBy: { name: 'asc' } });
}
export async function createSection(input: { eventId?: string; name?: string; allowedOptionIds?: string[] }) {
if (!input.eventId || !input.name) return fail(400, 'Event and section name are required');
const event = await prisma.event.findUnique({ where: { id: input.eventId }, select: { id: true } });
if (!event) return fail(404, 'Event not found');
const section = await prisma.section.create({ data: { id: uuidv4(), eventId: input.eventId, name: String(input.name), updatedAt: new Date() } });
if (Array.isArray(input.allowedOptionIds) && input.allowedOptionIds.length > 0) {
await prisma.sectionOption.createMany({
data: input.allowedOptionIds.map(optionId => ({ id: uuidv4(), sectionId: section.id, eventOptionId: optionId })),
skipDuplicates: true,
});
}
return prisma.section.findUniqueOrThrow({ where: { id: section.id }, include: SECTION_INCLUDE });
}
/** Renames a section and/or replaces its ticket types (when `allowedOptionIds` is sent). */
export async function updateSection(sectionId: string, input: { name?: string; allowedOptionIds?: string[] }) {
const section = await prisma.section.findUnique({ where: { id: sectionId } });
if (!section) return fail(404, 'Section not found');
await prisma.section.update({ where: { id: sectionId }, data: { name: input.name || section.name, updatedAt: new Date() } });
if (Array.isArray(input.allowedOptionIds)) {
await prisma.sectionOption.deleteMany({ where: { sectionId } });
if (input.allowedOptionIds.length > 0) {
await prisma.sectionOption.createMany({ data: input.allowedOptionIds.map(optionId => ({ id: uuidv4(), sectionId, eventOptionId: optionId })) });
}
}
return prisma.section.findUniqueOrThrow({ where: { id: sectionId }, include: SECTION_INCLUDE });
}
export async function deleteSection(sectionId: string) {
const section = await prisma.section.findUnique({ where: { id: sectionId }, select: { id: true } });
if (!section) return fail(404, 'Section not found');
await prisma.section.delete({ where: { id: sectionId } });
}
// ─── Planned costs (for cashup and the profit report) ────────────────────────
const COST_INCLUDE = { eventOption: { select: { id: true, name: true } } } as const;
function paidFromMethod(value: unknown): string | null | undefined {
if (value === undefined) return undefined;
if (value === null || value === '') return null;
if (!cashup.ALL_METHODS.includes(String(value))) fail(400, "paidFromMethod must be one of 'cash', 'card', 'eft', 'other', or null");
return String(value);
}
export function listCosts(eventId: string) {
return prisma.eventCost.findMany({ where: { eventId }, include: COST_INCLUDE, orderBy: { createdAt: 'asc' } });
}
export type CostInput = { label?: string; costType?: string; amount?: number | string; eventOptionId?: string | null; notes?: string | null; paidFromMethod?: string | null };
/** A cost per event ("hall hire") or per ticket sold ("T-shirt per camper"). */
export async function createCost(eventId: string, input: CostInput) {
await openEvent(eventId);
if (!input.label || !String(input.label).trim()) fail(400, 'Label is required');
if (input.costType !== 'once_off' && input.costType !== 'per_item') fail(400, "costType must be 'once_off' or 'per_item'");
const amount = parseFloat(String(input.amount));
if (!(amount >= 0)) fail(400, 'Amount must be a non-negative number');
if (input.costType === 'per_item') {
if (!input.eventOptionId) fail(400, 'eventOptionId is required for per-item costs');
const option = await prisma.eventOption.findUnique({ where: { id: input.eventOptionId! }, select: { eventId: true } });
if (!option || option.eventId !== eventId) fail(404, 'Ticket type not found for this event');
}
return prisma.eventCost.create({
data: {
id: uuidv4(), eventId, label: String(input.label).trim(), costType: input.costType as 'once_off' | 'per_item', amount,
eventOptionId: input.costType === 'per_item' ? input.eventOptionId! : null,
paidFromMethod: (paidFromMethod(input.paidFromMethod) ?? null) as any, notes: input.notes || null,
},
include: COST_INCLUDE,
});
}
export async function updateCost(costId: string, input: CostInput) {
const existing = await prisma.eventCost.findUnique({ where: { id: costId } });
if (!existing) return fail(404, 'Cost not found');
await openEvent(existing.eventId);
const costType = input.costType !== undefined ? input.costType : existing.costType;
if (costType !== 'once_off' && costType !== 'per_item') fail(400, "costType must be 'once_off' or 'per_item'");
const eventOptionId = costType === 'per_item' ? (input.eventOptionId !== undefined ? input.eventOptionId : existing.eventOptionId) : null;
if (costType === 'per_item') {
if (!eventOptionId) fail(400, 'eventOptionId is required for per-item costs');
const option = await prisma.eventOption.findUnique({ where: { id: eventOptionId! }, select: { eventId: true } });
if (!option || option.eventId !== existing.eventId) fail(404, 'Ticket type not found for this event');
}
let amount = existing.amount;
if (input.amount !== undefined) {
amount = parseFloat(String(input.amount));
if (!(amount >= 0)) fail(400, 'Amount must be a non-negative number');
}
const paid = paidFromMethod(input.paidFromMethod);
return prisma.eventCost.update({
where: { id: costId },
data: {
label: input.label !== undefined ? String(input.label).trim() : existing.label,
costType: costType as 'once_off' | 'per_item',
amount,
eventOptionId,
paidFromMethod: (paid !== undefined ? paid : existing.paidFromMethod) as any,
notes: input.notes !== undefined ? input.notes : existing.notes,
},
include: COST_INCLUDE,
});
}
export async function deleteCost(costId: string) {
const existing = await prisma.eventCost.findUnique({ where: { id: costId }, select: { eventId: true } });
if (!existing) return fail(404, 'Cost not found');
await openEvent(existing.eventId);
await prisma.eventCost.delete({ where: { id: costId } });
}
+25 -1
View File
@@ -13,7 +13,31 @@ type Successor = { method: string; v1: RegExp; v2: (m: RegExpMatchArray) => stri
const SUCCESSORS: Successor[] = [
{ method: 'GET', v1: /^\/api\/events\/?$/, v2: () => '/api/v2/events' },
{ method: 'GET', v1: /^\/api\/events\/([^/]+)$/, v2: m => `/api/v2/events/${m[1]}` },
// v1's event detail is the full record (v2's /events/{id} is the public summary).
{ method: 'GET', v1: /^\/api\/events\/([^/]+)$/, v2: m => `/api/v2/events/${m[1]}/full` },
// 1.51.8: the rest of the events area
{ method: 'GET', v1: /^\/api\/events\/([^/]+)\/ics$/, v2: m => `/api/v2/events/${m[1]}/calendar.ics` },
{ method: 'GET', v1: /^\/api\/events\/by-alias\/([^/]+)$/, v2: m => `/api/v2/events/by-alias/${m[1]}` },
{ method: 'POST', v1: /^\/api\/events\/([^/]+)\/options$/, v2: m => `/api/v2/events/${m[1]}/ticket-options` },
{ method: 'PUT', v1: /^\/api\/events\/options\/([^/]+)$/, v2: m => `/api/v2/ticket-options/${m[1]}` },
{ method: 'DELETE', v1: /^\/api\/events\/options\/([^/]+)$/, v2: m => `/api/v2/ticket-options/${m[1]}` },
{ method: 'POST', v1: /^\/api\/events\/options\/([^/]+)\/variants$/, v2: m => `/api/v2/ticket-options/${m[1]}/variants` },
{ method: 'PUT', v1: /^\/api\/events\/variants\/([^/]+)$/, v2: m => `/api/v2/variants/${m[1]}` },
{ method: 'DELETE', v1: /^\/api\/events\/variants\/([^/]+)$/, v2: m => `/api/v2/variants/${m[1]}` },
{ method: 'GET', v1: /^\/api\/events\/attachments\/status$/, v2: () => '/api/v2/attachments/status' },
{ method: 'POST', v1: /^\/api\/events\/attachments\/sync$/, v2: () => '/api/v2/attachments/sync' },
{ method: 'GET', v1: /^\/api\/events\/([^/]+)\/attachments$/, v2: m => `/api/v2/events/${m[1]}/attachments` },
{ method: 'POST', v1: /^\/api\/events\/([^/]+)\/attachments$/, v2: m => `/api/v2/events/${m[1]}/attachments` },
{ method: 'DELETE', v1: /^\/api\/events\/([^/]+)\/attachments\/([^/]+)$/, v2: m => `/api/v2/events/${m[1]}/attachments/${m[2]}` },
{ method: 'GET', v1: /^\/api\/sections\/?$/, v2: () => '/api/v2/sections' },
{ method: 'POST', v1: /^\/api\/sections\/?$/, v2: () => '/api/v2/sections' },
{ method: 'PUT', v1: /^\/api\/sections\/([^/]+)$/, v2: m => `/api/v2/sections/${m[1]}` },
{ method: 'DELETE', v1: /^\/api\/sections\/([^/]+)$/, v2: m => `/api/v2/sections/${m[1]}` },
{ method: 'GET', v1: /^\/api\/events\/([^/]+)\/costs$/, v2: m => `/api/v2/events/${m[1]}/costs` },
{ method: 'POST', v1: /^\/api\/events\/([^/]+)\/costs$/, v2: m => `/api/v2/events/${m[1]}/costs` },
{ method: 'PUT', v1: /^\/api\/costs\/([^/]+)$/, v2: m => `/api/v2/costs/${m[1]}` },
{ method: 'DELETE', v1: /^\/api\/costs\/([^/]+)$/, v2: m => `/api/v2/costs/${m[1]}` },
{ method: 'POST', v1: /^\/api\/uploads\/(event-image|logo|favicon)$/, v2: m => `/api/v2/uploads/${m[1]}` },
// 1.51.7: setting events up
{ method: 'GET', v1: /^\/api\/events\/all$/, v2: () => '/api/v2/events/manage' },
{ method: 'POST', v1: /^\/api\/events\/?$/, v2: () => '/api/v2/events' },
+1
View File
@@ -8,6 +8,7 @@ import auth from '../middleware/authMiddleware';
// eventsManage first: /events/manage must match before /events/:id.
import './resources/eventsManage';
import './resources/eventDetails';
import './resources/setup';
import './resources/events';
import './resources/me';
import './resources/registrations';
@@ -0,0 +1,229 @@
import { z } from 'zod';
import type { Request, RequestHandler } from 'express';
import { defineRoute } from '../route';
import { ApiError } from '../errors';
import { single } from '../paging';
import { absoluteUrl, id, idParams, isoDate } from '../schemas';
import * as setup from '../../services/setup';
import { prisma } from '../legacy';
import auth from '../../middleware/authMiddleware';
/* eslint-disable @typescript-eslint/no-explicit-any -- multer and the scope middleware are JS */
const campusScope = require('../../utils/campusScope') as {
listWhere(req: unknown, path?: string): Promise<object>;
scopeEvent(opts?: { need?: 'view' | 'manage'; resolve?: string; from?: (req: any) => unknown }): any;
};
const uploads = require('../../controllers/uploadController') as { upload: any; uploadLogo: any; uploadFavicon: any };
const plain = <T>(v: T): any => JSON.parse(JSON.stringify(v));
// ─── Sections ────────────────────────────────────────────────────────────────
const section = z.looseObject({
id, eventId: id, name: z.string(),
allowedOptions: z.array(z.looseObject({ eventOptionId: id, eventOption: z.looseObject({ id, name: z.string() }) })),
});
export const listSections = defineRoute({
method: 'get',
path: '/sections',
tag: 'Events (staff)',
summary: 'Scanning sections',
description: 'Which ticket types may come in at which door, for one event or every event you can see.',
access: 'staff',
campusScope: 'scopeList (listWhere)',
query: z.object({ eventId: id.optional() }),
response: z.object({ data: z.array(section.extend({ event: z.object({ id, title: z.string() }) })) }),
async handler({ query, req }) {
return { data: plain(await setup.listSections(query.eventId, await campusScope.listWhere(req, 'event'))) };
},
});
export const createSection = defineRoute({
method: 'post',
path: '/sections',
tag: 'Events (staff)',
summary: 'Add a scanning section',
access: 'supervisor',
campusScope: 'scopeEvent(body.eventId, manage)',
middleware: [campusScope.scopeEvent({ from: req => req.body?.eventId, need: 'manage' })],
status: 201,
body: z.object({ eventId: id, name: z.string().trim().min(1).max(120), allowedOptionIds: z.array(id).max(100).optional() }),
response: single(section),
async handler({ body }) {
return { data: plain(await setup.createSection(body)) };
},
});
export const updateSection = defineRoute({
method: 'patch',
path: '/sections/:id',
tag: 'Events (staff)',
summary: 'Change a scanning section',
description: '`allowedOptionIds`, when sent, replaces its ticket types.',
access: 'supervisor',
campusScope: 'scopeEvent(section, manage)',
middleware: [campusScope.scopeEvent({ resolve: 'section', need: 'manage' })],
params: idParams,
body: z.object({ name: z.string().trim().min(1).max(120).optional(), allowedOptionIds: z.array(id).max(100).optional() }),
response: single(section),
async handler({ params, body }) {
return { data: plain(await setup.updateSection(params.id, body)) };
},
});
export const deleteSection = defineRoute({
method: 'delete',
path: '/sections/:id',
tag: 'Events (staff)',
summary: 'Remove a scanning section',
access: 'admin',
params: idParams,
response: single(z.object({ id, deleted: z.literal(true) })),
async handler({ params }) {
await setup.deleteSection(params.id);
return { data: { id: params.id, deleted: true as const } };
},
});
// ─── Planned costs ───────────────────────────────────────────────────────────
const cost = z.object({
id, eventId: id, label: z.string(), costType: z.enum(['once_off', 'per_item']), amount: z.number(),
eventOptionId: id.nullable(), eventOption: z.object({ id, name: z.string() }).nullable(),
paidFromMethod: z.string().nullable().describe('How it was paid out of the takings (cash, card, eft, other)'),
notes: z.string().nullable(), createdAt: isoDate, updatedAt: isoDate.optional(),
});
const costBody = z.object({
label: z.string().trim().min(1).max(200),
costType: z.enum(['once_off', 'per_item']).describe('per_item = per ticket sold of `eventOptionId`'),
amount: z.union([z.number().min(0), z.string().max(20)]),
eventOptionId: id.nullable().optional(),
notes: z.string().max(2000).nullable().optional(),
paidFromMethod: z.enum(['cash', 'card', 'eft', 'other']).nullable().optional(),
});
export const listCosts = defineRoute({
method: 'get',
path: '/events/:id/costs',
tag: 'Events (staff)',
summary: 'An event\'s planned costs',
access: 'supervisor',
campusScope: 'scopeEvent(manage)',
middleware: [campusScope.scopeEvent({ need: 'manage' })],
params: idParams,
response: z.object({ data: z.array(cost) }),
async handler({ params }) {
return { data: plain(await setup.listCosts(params.id)) };
},
});
export const createCost = defineRoute({
method: 'post',
path: '/events/:id/costs',
tag: 'Events (staff)',
summary: 'Add a planned cost',
description: 'Admins. Not on a cashed-up event.',
access: 'admin',
status: 201,
params: idParams,
body: costBody,
response: single(cost),
async handler({ params, body }) {
return { data: plain(await setup.createCost(params.id, body)) };
},
});
export const updateCost = defineRoute({
method: 'patch',
path: '/costs/:id',
tag: 'Events (staff)',
summary: 'Change a planned cost',
access: 'admin',
params: idParams,
body: costBody.partial(),
response: single(cost),
async handler({ params, body }) {
return { data: plain(await setup.updateCost(params.id, body)) };
},
});
export const deleteCost = defineRoute({
method: 'delete',
path: '/costs/:id',
tag: 'Events (staff)',
summary: 'Remove a planned cost',
access: 'admin',
params: idParams,
response: single(z.object({ id, deleted: z.literal(true) })),
async handler({ params }) {
await setup.deleteCost(params.id);
return { data: { id: params.id, deleted: true as const } };
},
});
// ─── Image uploads ───────────────────────────────────────────────────────────
/** Runs a multer step for field "image", keeping any error on the request. */
const receive = (m: any): RequestHandler => (req, res, next) => m.single('image')(req, res, (e: Error | undefined) => {
if (e) (req as Request & { multerError?: Error }).multerError = e;
next();
});
/** Branding images: admins — or anyone during first-time setup, before any account exists. */
const brandingAccess: RequestHandler = async (req, res, next) => {
try {
if (await prisma.user.count() === 0) return next();
} catch { /* fall through to the admin check */ }
auth.protect(req, res, (e?: unknown) => (e ? next(e) : auth.admin(req, res, next)));
};
const uploaded = (folder: string) => async ({ req }: { req: Request }) => {
const r = req as Request & { multerError?: Error; file?: { filename: string } };
if (r.multerError) throw new ApiError('VALIDATION_FAILED', `Upload failed: ${r.multerError.message}`, { image: r.multerError.message });
if (!r.file) throw new ApiError('VALIDATION_FAILED', 'No file uploaded', { image: 'Choose an image' });
const path = `/uploads/${folder}/${r.file.filename}`;
return { data: { path, url: absoluteUrl(req, path)! } };
};
const uploadResult = single(z.object({ path: z.string().describe('What to save on the event or setting'), url: z.string().describe('The same, as a full address') }));
const IMAGE = 'A JPEG, PNG, GIF or WebP image';
const LOGO = 'A JPEG, PNG, WebP or SVG image';
export const uploadEventImage = defineRoute({
method: 'post',
path: '/uploads/event-image',
tag: 'Uploads',
summary: 'Upload an event picture',
description: 'Returns the path to save as the event\'s `picture`.',
access: 'supervisor',
campusScope: 'campusIndependent (only stores the file; the event is checked when it is saved)',
middleware: [receive(uploads.upload)],
upload: { field: 'image', description: IMAGE },
response: uploadResult,
handler: uploaded('events'),
});
export const uploadLogo = defineRoute({
method: 'post',
path: '/uploads/logo',
tag: 'Uploads',
summary: 'Upload the site logo',
description: 'Admins — or anyone during first-time setup, before any account exists.',
access: 'public',
middleware: [brandingAccess, receive(uploads.uploadLogo)],
upload: { field: 'image', description: LOGO },
response: uploadResult,
handler: uploaded('branding'),
});
export const uploadFavicon = defineRoute({
method: 'post',
path: '/uploads/favicon',
tag: 'Uploads',
summary: 'Upload the site icon (favicon)',
description: 'Admins — or anyone during first-time setup, before any account exists.',
access: 'public',
middleware: [brandingAccess, receive(uploads.uploadFavicon)],
upload: { field: 'image', description: 'An ICO, PNG or SVG image' },
response: uploadResult,
handler: uploaded('branding'),
});
+54 -1
View File
@@ -49,6 +49,7 @@ jest.mock('../src/utils/campusScope', () => ({
// Route-level checks: refuse like v1 does (v1 shape — the v2 wrapper isn't in this test app).
scopeEvent: () => (_req: unknown, res: { status(n: number): { json(b: unknown): void } }, next: () => void) => (mockScope.blockEvent ? res.status(404).json({ message: 'Not found' }) : next()),
scopeBody: () => (_req: unknown, _res: unknown, next: () => void) => next(),
listWhere: async () => ({}),
}));
const mockEvents = { listManagedEvents: jest.fn(), createEvent: jest.fn(), updateEvent: jest.fn(), deactivateEvent: jest.fn(), getNotifyRecipients: jest.fn(), setNotifyRecipients: jest.fn(), copySetupFrom: jest.fn() };
jest.mock('../src/services/events', () => Object.fromEntries(Object.keys(mockEvents).map(k => [k, (...a: unknown[]) => (mockEvents as Record<string, jest.Mock>)[k](...a)])));
@@ -65,6 +66,15 @@ jest.mock('../src/controllers/eventController', () => ({
receiveAttachment: (req: { file?: object; multerError?: Error }, _res: unknown, next: () => void) => { if (mockUpload.error) req.multerError = mockUpload.error; else if (mockUpload.file) req.file = mockUpload.file; next(); },
}));
const mockSetup = { listSections: jest.fn(), createSection: jest.fn(), updateSection: jest.fn(), deleteSection: jest.fn(), listCosts: jest.fn(), createCost: jest.fn(), updateCost: jest.fn(), deleteCost: jest.fn() };
jest.mock('../src/services/setup', () => Object.fromEntries(Object.keys(mockSetup).map(k => [k, (...a: unknown[]) => (mockSetup as Record<string, jest.Mock>)[k](...a)])));
// Image uploads: a stand-in for multer that "saves" mockImage.
const mockImage = { file: null as object | null };
jest.mock('../src/controllers/uploadController', () => {
const m = { single: () => (req: { file?: object }, _res: unknown, cb: () => void) => { if (mockImage.file) req.file = mockImage.file; cb(); } };
return { upload: m, uploadLogo: m, uploadFavicon: m };
});
import { v2Router } from '../src/v2';
import { ServiceError } from '../src/services/errors';
import { routes } from '../src/v2/route';
@@ -359,7 +369,9 @@ describe('v1 deprecation headers', () => {
const { successorOf } = require('../src/v2/deprecation');
test('v1 endpoints with a v2 replacement point at it; the rest say nothing', () => {
expect(successorOf('GET', '/api/events')).toBe('/api/v2/events');
expect(successorOf('GET', '/api/events/e1')).toBe('/api/v2/events/e1');
expect(successorOf('GET', '/api/events/e1')).toBe('/api/v2/events/e1/full');
expect(successorOf('PUT', '/api/events/options/o1')).toBe('/api/v2/ticket-options/o1');
expect(successorOf('DELETE', '/api/events/e1/attachments/a1')).toBe('/api/v2/events/e1/attachments/a1');
expect(successorOf('GET', '/api/events/all')).toBe('/api/v2/events/manage');
expect(successorOf('PUT', '/api/events/e1')).toBe('/api/v2/events/e1');
expect(successorOf('DELETE', '/api/registrations/r1')).toBe('/api/v2/registrations/r1/cancel');
@@ -501,3 +513,44 @@ describe('one event in full, options, attachments', () => {
expect(Object.keys(doc.paths['/events/{id}/calendar.ics'].get.responses['200'].content)).toEqual(['text/calendar']);
});
});
describe('sections, costs, image uploads', () => {
afterEach(() => { mockImage.file = null; });
test('costs: supervisors read them, admins add them; per-item needs a ticket type', async () => {
signedIn = { id: 'v1', role: 'supervisor' };
mockSetup.listCosts.mockResolvedValue([{ id: 'c1', eventId: 'e1', label: 'Hall', costType: 'once_off', amount: 1500, eventOptionId: null, eventOption: null, paidFromMethod: null, notes: null, createdAt: new Date('2026-10-01T10:00:00Z') }]);
expect((await request(app).get('/api/v2/events/e1/costs')).body.data[0]).toMatchObject({ label: 'Hall', createdAt: '2026-10-01T10:00:00.000Z' });
expect((await request(app).post('/api/v2/events/e1/costs').send({ label: 'Hall', costType: 'once_off', amount: 1500 })).status).toBe(403);
signedIn = { id: 'a1', role: 'admin' };
expect((await request(app).post('/api/v2/events/e1/costs').send({ label: 'Hall', costType: 'monthly', amount: 1 })).body.error.fields).toHaveProperty('costType');
mockSetup.createCost.mockRejectedValueOnce(new ServiceError(400, 'eventOptionId is required for per-item costs'));
expect((await request(app).post('/api/v2/events/e1/costs').send({ label: 'Shirt', costType: 'per_item', amount: 80 })).body.error.message).toBe('eventOptionId is required for per-item costs');
});
test('sections need staff to list and a supervisor to add', async () => {
signedIn = { id: 'u1', role: 'user' };
expect((await request(app).get('/api/v2/sections')).status).toBe(403);
signedIn = { id: 's1', role: 'staff' };
mockSetup.listSections.mockResolvedValue([]);
expect((await request(app).get('/api/v2/sections?eventId=e1')).body).toEqual({ data: [] });
expect(mockSetup.listSections).toHaveBeenCalledWith('e1', expect.anything());
});
test('an event picture comes back as a path to save and a full address', async () => {
signedIn = { id: 'v1', role: 'supervisor' };
expect((await request(app).post('/api/v2/uploads/event-image')).body.error.fields).toEqual({ image: 'Choose an image' });
mockImage.file = { filename: 'event-123.jpg' };
const res = await request(app).post('/api/v2/uploads/event-image');
expect(res.body.data.path).toBe('/uploads/events/event-123.jpg');
expect(res.body.data.url).toMatch(/^http:\/\/.*\/uploads\/events\/event-123\.jpg$/);
});
test('branding images are for admins once accounts exist', async () => {
signedIn = { id: 'v1', role: 'supervisor' };
mockImage.file = { filename: 'logo.png' };
expect((await request(app).post('/api/v2/uploads/logo')).status).toBe(403);
signedIn = { id: 'a1', role: 'admin' };
expect((await request(app).post('/api/v2/uploads/logo')).body.data.path).toBe('/uploads/branding/logo.png');
});
});
File diff suppressed because it is too large Load Diff
+928
View File
@@ -386,6 +386,174 @@ export interface paths {
patch?: never;
trace?: never;
};
"/sections": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
/**
* Scanning sections
* @description Which ticket types may come in at which door, for one event or every event you can see.
*
* **Who:** Staff, supervisors and admins.
*/
get: operations["getSections"];
put?: never;
/**
* Add a scanning section
* @description **Who:** Supervisors and admins.
*/
post: operations["postSections"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/sections/{id}": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
post?: never;
/**
* Remove a scanning section
* @description **Who:** Admins only.
*/
delete: operations["deleteSectionsId"];
options?: never;
head?: never;
/**
* Change a scanning section
* @description `allowedOptionIds`, when sent, replaces its ticket types.
*
* **Who:** Supervisors and admins.
*/
patch: operations["patchSectionsId"];
trace?: never;
};
"/events/{id}/costs": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
/**
* An event's planned costs
* @description **Who:** Supervisors and admins.
*/
get: operations["getEventsIdCosts"];
put?: never;
/**
* Add a planned cost
* @description Admins. Not on a cashed-up event.
*
* **Who:** Admins only.
*/
post: operations["postEventsIdCosts"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/costs/{id}": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
post?: never;
/**
* Remove a planned cost
* @description **Who:** Admins only.
*/
delete: operations["deleteCostsId"];
options?: never;
head?: never;
/**
* Change a planned cost
* @description **Who:** Admins only.
*/
patch: operations["patchCostsId"];
trace?: never;
};
"/uploads/event-image": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/**
* Upload an event picture
* @description Returns the path to save as the event's `picture`.
*
* **Who:** Supervisors and admins.
*/
post: operations["postUploadsEvent-image"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/uploads/logo": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/**
* Upload the site logo
* @description Admins — or anyone during first-time setup, before any account exists.
*
* **Who:** Anyone.
*/
post: operations["postUploadsLogo"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/uploads/favicon": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/**
* Upload the site icon (favicon)
* @description Admins — or anyone during first-time setup, before any account exists.
*
* **Who:** Anyone.
*/
post: operations["postUploadsFavicon"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/registrations": {
parameters: {
query?: never;
@@ -2470,6 +2638,766 @@ export interface operations {
};
};
};
getSections: {
parameters: {
query?: {
eventId?: string;
};
header?: never;
path?: never;
cookie?: never;
};
requestBody?: never;
responses: {
/** @description OK */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": {
data: ({
id: string;
eventId: string;
name: string;
allowedOptions: ({
eventOptionId: string;
eventOption: {
id: string;
name: string;
} & {
[key: string]: unknown;
};
} & {
[key: string]: unknown;
})[];
event: {
id: string;
title: string;
};
} & {
[key: string]: unknown;
})[];
};
};
};
/** @description Validation failed (VALIDATION_FAILED) */
400: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Not signed in (UNAUTHENTICATED) */
401: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Not allowed for this role (FORBIDDEN) */
403: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
};
};
postSections: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": {
eventId: string;
name: string;
allowedOptionIds?: string[];
};
};
};
responses: {
/** @description OK */
201: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": {
data: {
id: string;
eventId: string;
name: string;
allowedOptions: ({
eventOptionId: string;
eventOption: {
id: string;
name: string;
} & {
[key: string]: unknown;
};
} & {
[key: string]: unknown;
})[];
} & {
[key: string]: unknown;
};
};
};
};
/** @description Validation failed (VALIDATION_FAILED) */
400: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Not signed in (UNAUTHENTICATED) */
401: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Not allowed for this role (FORBIDDEN) */
403: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
};
};
deleteSectionsId: {
parameters: {
query?: never;
header?: never;
path: {
/** @description The id */
id: string;
};
cookie?: never;
};
requestBody?: never;
responses: {
/** @description OK */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": {
data: {
id: string;
/** @constant */
deleted: true;
};
};
};
};
/** @description Validation failed (VALIDATION_FAILED) */
400: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Not signed in (UNAUTHENTICATED) */
401: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Not allowed for this role (FORBIDDEN) */
403: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Not found (NOT_FOUND) */
404: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
};
};
patchSectionsId: {
parameters: {
query?: never;
header?: never;
path: {
/** @description The id */
id: string;
};
cookie?: never;
};
requestBody: {
content: {
"application/json": {
name?: string;
allowedOptionIds?: string[];
};
};
};
responses: {
/** @description OK */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": {
data: {
id: string;
eventId: string;
name: string;
allowedOptions: ({
eventOptionId: string;
eventOption: {
id: string;
name: string;
} & {
[key: string]: unknown;
};
} & {
[key: string]: unknown;
})[];
} & {
[key: string]: unknown;
};
};
};
};
/** @description Validation failed (VALIDATION_FAILED) */
400: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Not signed in (UNAUTHENTICATED) */
401: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Not allowed for this role (FORBIDDEN) */
403: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Not found (NOT_FOUND) */
404: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
};
};
getEventsIdCosts: {
parameters: {
query?: never;
header?: never;
path: {
/** @description The id */
id: string;
};
cookie?: never;
};
requestBody?: never;
responses: {
/** @description OK */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": {
data: {
id: string;
eventId: string;
label: string;
/** @enum {string} */
costType: "once_off" | "per_item";
amount: number;
eventOptionId: string | null;
eventOption: {
id: string;
name: string;
} | null;
/** @description How it was paid out of the takings (cash, card, eft, other) */
paidFromMethod: string | null;
notes: string | null;
/** Format: date-time */
createdAt: string;
/** Format: date-time */
updatedAt?: string;
}[];
};
};
};
/** @description Validation failed (VALIDATION_FAILED) */
400: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Not signed in (UNAUTHENTICATED) */
401: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Not allowed for this role (FORBIDDEN) */
403: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Not found (NOT_FOUND) */
404: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
};
};
postEventsIdCosts: {
parameters: {
query?: never;
header?: never;
path: {
/** @description The id */
id: string;
};
cookie?: never;
};
requestBody: {
content: {
"application/json": {
label: string;
/**
* @description per_item = per ticket sold of `eventOptionId`
* @enum {string}
*/
costType: "once_off" | "per_item";
amount: number | string;
eventOptionId?: string | null;
notes?: string | null;
paidFromMethod?: ("cash" | "card" | "eft" | "other") | null;
};
};
};
responses: {
/** @description OK */
201: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": {
data: {
id: string;
eventId: string;
label: string;
/** @enum {string} */
costType: "once_off" | "per_item";
amount: number;
eventOptionId: string | null;
eventOption: {
id: string;
name: string;
} | null;
/** @description How it was paid out of the takings (cash, card, eft, other) */
paidFromMethod: string | null;
notes: string | null;
/** Format: date-time */
createdAt: string;
/** Format: date-time */
updatedAt?: string;
};
};
};
};
/** @description Validation failed (VALIDATION_FAILED) */
400: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Not signed in (UNAUTHENTICATED) */
401: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Not allowed for this role (FORBIDDEN) */
403: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Not found (NOT_FOUND) */
404: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
};
};
deleteCostsId: {
parameters: {
query?: never;
header?: never;
path: {
/** @description The id */
id: string;
};
cookie?: never;
};
requestBody?: never;
responses: {
/** @description OK */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": {
data: {
id: string;
/** @constant */
deleted: true;
};
};
};
};
/** @description Validation failed (VALIDATION_FAILED) */
400: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Not signed in (UNAUTHENTICATED) */
401: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Not allowed for this role (FORBIDDEN) */
403: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Not found (NOT_FOUND) */
404: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
};
};
patchCostsId: {
parameters: {
query?: never;
header?: never;
path: {
/** @description The id */
id: string;
};
cookie?: never;
};
requestBody: {
content: {
"application/json": {
label?: string;
/**
* @description per_item = per ticket sold of `eventOptionId`
* @enum {string}
*/
costType?: "once_off" | "per_item";
amount?: number | string;
eventOptionId?: string | null;
notes?: string | null;
paidFromMethod?: ("cash" | "card" | "eft" | "other") | null;
};
};
};
responses: {
/** @description OK */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": {
data: {
id: string;
eventId: string;
label: string;
/** @enum {string} */
costType: "once_off" | "per_item";
amount: number;
eventOptionId: string | null;
eventOption: {
id: string;
name: string;
} | null;
/** @description How it was paid out of the takings (cash, card, eft, other) */
paidFromMethod: string | null;
notes: string | null;
/** Format: date-time */
createdAt: string;
/** Format: date-time */
updatedAt?: string;
};
};
};
};
/** @description Validation failed (VALIDATION_FAILED) */
400: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Not signed in (UNAUTHENTICATED) */
401: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Not allowed for this role (FORBIDDEN) */
403: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Not found (NOT_FOUND) */
404: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
};
};
"postUploadsEvent-image": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"multipart/form-data": {
/**
* Format: binary
* @description A JPEG, PNG, GIF or WebP image
*/
image: string;
};
};
};
responses: {
/** @description OK */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": {
data: {
/** @description What to save on the event or setting */
path: string;
/** @description The same, as a full address */
url: string;
};
};
};
};
/** @description Not signed in (UNAUTHENTICATED) */
401: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
/** @description Not allowed for this role (FORBIDDEN) */
403: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["Error"];
};
};
};
};
postUploadsLogo: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"multipart/form-data": {
/**
* Format: binary
* @description A JPEG, PNG, WebP or SVG image
*/
image: string;
};
};
};
responses: {
/** @description OK */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": {
data: {
/** @description What to save on the event or setting */
path: string;
/** @description The same, as a full address */
url: string;
};
};
};
};
};
};
postUploadsFavicon: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"multipart/form-data": {
/**
* Format: binary
* @description An ICO, PNG or SVG image
*/
image: string;
};
};
};
responses: {
/** @description OK */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": {
data: {
/** @description What to save on the event or setting */
path: string;
/** @description The same, as a full address */
url: string;
};
};
};
};
};
};
postRegistrations: {
parameters: {
query?: never;