Open-source event management and ticket selling platform — perfect for concerts, conferences, and everything in between 🎟️ If you find this project helpful, please consider giving us a star ⭐️
PHP attendize-alternativedoor-managementevent-check-inevent-managementevent-registrationevent-ticketingeventbrite-alternativeeventslaravelopen-sourcephpreactself-hostedsell-ticketssell-tickets-onlineticket-sellingticketing-systemtickettailor-alternativetito-alternative
import { readFileSync } from 'node:fs';
import { fileURLToPath } from 'node:url';
import type { APIRequestContext } from '@playwright/test';
import type { ApiClient } from './api-client';
import type {
AttendeeDetailsCollection,
EventType,
Occurrence,
Organizer,
ProductPriceType,
PublicOrder,
QuestionRecord,
} from './types';
import {
awaitOfflinePayment,
completePublicOrder,
createBoxOfficeOrder,
createPublicOrder,
getPublicOrder,
startBoxOfficeSession,
tenderBoxOfficeOrder,
type DoorOrder,
type QuestionAnswer,
} from './public-client';
import { uniqueEmail, uniqueName } from '../utils/unique';
export interface SeededEvent {
eventId: number;
slug: string;
title: string;
productId: number;
productTitle: string;
priceId: number;
}
interface SeedOptions {
organizerId: number;
startDate?: string;
price?: number;
productType?: ProductPriceType;
eventType?: EventType;
category?: string;
title?: string;
productTitle?: string;
productDescription?: string;
quantityAvailable?: number;
waitlistEnabled?: boolean;
hideWhenSoldOut?: boolean;
showQuantityRemaining?: boolean;
taxIds?: number[];
prices?: { price: number; label?: string; initial_quantity_available?: number }[];
sequentialTierReleaseEnabled?: boolean;
attendeeDetails?: AttendeeDetailsCollection;
currency?: string;
}
export const setAttendeeDetailsCollection = (
api: ApiClient,
eventId: number,
method: AttendeeDetailsCollection,
): Promise<void> => api.updateEventSettings(eventId, { attendee_details_collection_method: method });
export const futureStartDate = (): string => {
const date = new Date();
date.setDate(date.getDate() + 30);
date.setHours(21, 0, 0, 0);
return date.toISOString();
};
export const tomorrowUtcDate = (): string => {
const date = new Date();
date.setUTCDate(date.getUTCDate() + 1);
return date.toISOString().slice(0, 10);
};
const pastStartDate = (): string => {
const date = new Date();
date.setDate(date.getDate() - 30);
date.setHours(21, 0, 0, 0);
return date.toISOString();
};
const coverImage = (): { name: string; mimeType: string; buffer: Buffer } => ({
name: 'event-cover.png',
mimeType: 'image/png',
buffer: readFileSync(fileURLToPath(new URL('../fixtures/assets/event-cover.png', import.meta.url))),
});
export async function createLiveEventWithProduct(api: ApiClient, opts: SeedOptions): Promise<SeededEvent> {
const {
organizerId,
price = 0,
productType = price > 0 ? 'PAID' : 'FREE',
eventType = 'SINGLE',
category = 'MUSIC',
title = uniqueName('E2E Event'),
productTitle = productType === 'FREE' ? 'Free Ticket' : 'Paid Ticket',
} = opts;
const event = await api.createEvent({
title,
type: eventType,
organizer_id: organizerId,
start_date: opts.startDate ?? futureStartDate(),
category,
currency: opts.currency ?? 'USD',
timezone: 'UTC',
});
if (eventType === 'SINGLE') {
await setAttendeeDetailsCollection(api, event.id, opts.attendeeDetails ?? 'PER_TICKET');
}
const categories = await api.listProductCategories(event.id);
const categoryId = categories[0].id;
const created = await api.createProduct(event.id, {
title: productTitle,
...(opts.productDescription !== undefined ? { description: opts.productDescription } : {}),
product_type: 'TICKET',
type: productType,
product_category_id: categoryId,
prices: (opts.prices ?? [{ price }]).map((priceEntry) => ({
...(opts.quantityAvailable !== undefined ? { initial_quantity_available: opts.quantityAvailable } : {}),
...priceEntry,
})),
...(opts.waitlistEnabled !== undefined ? { waitlist_enabled: opts.waitlistEnabled } : {}),
...(opts.hideWhenSoldOut !== undefined ? { hide_when_sold_out: opts.hideWhenSoldOut } : {}),
...(opts.showQuantityRemaining !== undefined ? { show_quantity_remaining: opts.showQuantityRemaining } : {}),
...(opts.sequentialTierReleaseEnabled !== undefined ? { sequential_tier_release_enabled: opts.sequentialTierReleaseEnabled } : {}),
...(opts.taxIds ? { tax_and_fee_ids: opts.taxIds } : {}),
});
const product = await api.getProduct(event.id, created.id);
const priceId = product.prices?.[0]?.id;
if (!priceId) {
throw new Error(`Product ${created.id} has no prices in GET response`);
}
await api.publishEvent(event.id);
return { eventId: event.id, slug: event.slug, title, productId: created.id, productTitle, priceId };
}
export interface SeededDraftEvent {
eventId: number;
slug: string;
title: string;
}
export async function createDraftEvent(
api: ApiClient,
organizerId: number,
opts: { title?: string; attendeeDetails?: AttendeeDetailsCollection; currency?: string } = {},
): Promise<SeededDraftEvent> {
const title = opts.title ?? uniqueName('E2E Event');
const event = await api.createEvent({
title,
type: 'SINGLE',
organizer_id: organizerId,
start_date: futureStartDate(),
category: 'MUSIC',
currency: opts.currency ?? 'USD',
timezone: 'UTC',
});
await setAttendeeDetailsCollection(api, event.id, opts.attendeeDetails ?? 'PER_TICKET');
return { eventId: event.id, slug: event.slug, title };
}
export async function createDraftEventWithTicket(
api: ApiClient,
organizerId: number,
opts: { title?: string; productTitle?: string; price?: number } = {},
): Promise<SeededEvent & { categoryId: number }> {
const { eventId, slug, title } = await createDraftEvent(api, organizerId, opts);
const categories = await api.listProductCategories(eventId);
const categoryId = categories[0].id;
const price = opts.price ?? 0;
const productTitle = opts.productTitle ?? 'General Admission';
const created = await api.createProduct(eventId, {
title: productTitle,
product_type: 'TICKET',
type: price > 0 ? 'PAID' : 'FREE',
product_category_id: categoryId,
prices: [{ price }],
});
const product = await api.getProduct(eventId, created.id);
const priceId = product.prices?.[0]?.id;
if (!priceId) {
throw new Error(`Product ${created.id} has no prices in GET response`);
}
return { eventId, slug, title, productId: created.id, productTitle, categoryId, priceId };
}
export const createLiveEventWithFreeTicket = (api: ApiClient, organizerId: number): Promise<SeededEvent> =>
createLiveEventWithProduct(api, { organizerId, price: 0 });
export const createLiveEventWithPaidTicket = (
api: ApiClient,
organizerId: number,
price = 25,
): Promise<SeededEvent> => createLiveEventWithProduct(api, { organizerId, price });
export interface SeededOrder {
orderShortId: string;
sessionId: string;
buyerEmail: string;
buyerFirstName: string;
buyerLastName: string;
attendees: { shortId: string; publicId: string }[];
}
export interface OrderSeedOptions {
buyerEmail?: string;
buyerFirstName?: string;
buyerLastName?: string;
quantity?: number;
promoCode?: string;
affiliateCode?: string;
eventOccurrenceId?: number;
seatUids?: string[];
orderQuestions?: QuestionAnswer[];
attendeeQuestions?: QuestionAnswer[];
}
const mapAttendees = (order: PublicOrder): { shortId: string; publicId: string }[] =>
(order.attendees ?? []).map((attendee) => ({ shortId: attendee.short_id, publicId: attendee.public_id }));
export async function createReservedOrder(
publicApi: APIRequestContext,
event: Pick<SeededEvent, 'eventId' | 'productId' | 'priceId'>,
opts: OrderSeedOptions = {},
): Promise<{ orderShortId: string; sessionId: string }> {
const order = await createPublicOrder(publicApi, event.eventId, {
products: [
{
product_id: event.productId,
quantities: [{
price_id: event.priceId,
quantity: opts.seatUids?.length ?? opts.quantity ?? 1,
...(opts.seatUids ? { seat_uids: opts.seatUids } : {}),
}],
...(opts.eventOccurrenceId ? { event_occurrence_id: opts.eventOccurrenceId } : {}),
},
],
promoCode: opts.promoCode,
affiliateCode: opts.affiliateCode,
});
if (!order.session_identifier) {
throw new Error(`Created order ${order.short_id} has no session_identifier in the response`);
}
return { orderShortId: order.short_id, sessionId: order.session_identifier };
}
export async function createCompletedOrder(
publicApi: APIRequestContext,
event: Pick<SeededEvent, 'eventId' | 'productId' | 'priceId'>,
opts: OrderSeedOptions = {},
): Promise<SeededOrder> {
const buyerEmail = opts.buyerEmail ?? uniqueEmail('buyer');
const buyerFirstName = opts.buyerFirstName ?? 'Test';
const buyerLastName = opts.buyerLastName ?? 'Buyer';
const quantity = opts.seatUids?.length ?? opts.quantity ?? 1;
const { orderShortId, sessionId } = await createReservedOrder(publicApi, event, opts);
await completePublicOrder(publicApi, event.eventId, orderShortId, sessionId, {
order: {
first_name: buyerFirstName,
last_name: buyerLastName,
email: buyerEmail,
...(opts.orderQuestions ? { questions: opts.orderQuestions } : {}),
},
attendees: Array.from({ length: quantity }, () => ({
product_id: event.productId,
product_price_id: event.priceId,
first_name: buyerFirstName,
last_name: buyerLastName,
email: buyerEmail,
...(opts.attendeeQuestions ? { questions: opts.attendeeQuestions } : {}),
})),
});
const completed = await getPublicOrder(publicApi, event.eventId, orderShortId, sessionId);
return {
orderShortId,
sessionId,
buyerEmail,
buyerFirstName,
buyerLastName,
attendees: mapAttendees(completed),
};
}
export const OFFLINE_PAYMENT_INSTRUCTIONS = 'Pay by bank transfer to account 12345678 within 5 days.';
export async function enableOfflinePayments(api: ApiClient, eventId: number): Promise<void> {
await api.updateEventSettings(eventId, {
payment_providers: ['OFFLINE'],
offline_payment_instructions: OFFLINE_PAYMENT_INSTRUCTIONS,
});
}
export async function createAwaitingOfflineOrder(
api: ApiClient,
publicApi: APIRequestContext,
event: Pick<SeededEvent, 'eventId' | 'productId' | 'priceId'>,
opts: OrderSeedOptions = {},
): Promise<SeededOrder & { orderId: number }> {
await enableOfflinePayments(api, event.eventId);
const seeded = await createCompletedOrder(publicApi, event, opts);
await awaitOfflinePayment(publicApi, event.eventId, seeded.orderShortId, seeded.sessionId);
const orderId = await api.findOrderIdByShortId(event.eventId, seeded.orderShortId);
return { ...seeded, orderId };
}
export async function createCompletedPaidOrder(
api: ApiClient,
publicApi: APIRequestContext,
event: Pick<SeededEvent, 'eventId' | 'productId' | 'priceId'>,
opts: OrderSeedOptions = {},
): Promise<SeededOrder & { orderId: number; totalGross: number }> {
const seeded = await createAwaitingOfflineOrder(api, publicApi, event, opts);
await api.markOrderAsPaid(event.eventId, seeded.orderId);
const completed = await getPublicOrder(publicApi, event.eventId, seeded.orderShortId, seeded.sessionId);
return { ...seeded, attendees: mapAttendees(completed), totalGross: completed.total_gross };
}
export async function createSoldOutEvent(
api: ApiClient,
publicApi: APIRequestContext,
organizerId: number,
opts: { waitlist?: boolean; title?: string } = {},
): Promise<SeededEvent & { consumedOrder: SeededOrder }> {
const event = await createLiveEventWithProduct(api, {
organizerId,
price: 0,
title: opts.title,
quantityAvailable: 1,
waitlistEnabled: opts.waitlist ?? false,
});
const consumedOrder = await createCompletedOrder(publicApi, event);
return { ...event, consumedOrder };
}
export async function createPastEventWithCoverImage(
api: ApiClient,
organizerId: number,
opts: { title?: string; eventType?: EventType } = {},
): Promise<SeededEvent> {
const event = await createLiveEventWithProduct(api, {
organizerId,
startDate: pastStartDate(),
title: opts.title,
eventType: opts.eventType,
});
if (opts.eventType === 'RECURRING') {
await api.createOccurrence(event.eventId, { start_date: pastStartDate() });
}
await api.uploadEventImage(event.eventId, coverImage());
return event;
}
export async function createRecurringLiveEvent(
api: ApiClient,
organizerId: number,
opts: {
count?: number;
price?: number;
title?: string;
quantityAvailable?: number;
quantityAppliesTo?: 'OCCURRENCE' | 'EVENT';
waitlistEnabled?: boolean;
showQuantityRemaining?: boolean;
} = {},
): Promise<SeededEvent & { occurrences: Occurrence[] }> {
const count = opts.count ?? 3;
const price = opts.price ?? 0;
const title = opts.title ?? uniqueName('E2E Recurring');
const event = await api.createEvent({
title,
type: 'RECURRING',
organizer_id: organizerId,
start_date: futureStartDate(),
category: 'MUSIC',
currency: 'USD',
timezone: 'UTC',
});
await api.generateOccurrences(event.id, {
frequency: 'weekly',
range: { type: 'count', count, start: tomorrowUtcDate() },
days_of_week: ['friday'],
times_of_day: ['19:00'],
duration_minutes: 120,
});
const occurrences = await api.listOccurrences(event.id);
const categories = await api.listProductCategories(event.id);
const created = await api.createProduct(event.id, {
title: price > 0 ? 'Paid Ticket' : 'Free Ticket',
product_type: 'TICKET',
type: price > 0 ? 'PAID' : 'FREE',
product_category_id: categories[0].id,
prices: [{
price,
...(opts.quantityAvailable !== undefined ? { initial_quantity_available: opts.quantityAvailable } : {}),
...(opts.quantityAppliesTo ? { quantity_applies_to: opts.quantityAppliesTo } : {}),
}],
...(opts.waitlistEnabled !== undefined ? { waitlist_enabled: opts.waitlistEnabled } : {}),
...(opts.showQuantityRemaining !== undefined ? { show_quantity_remaining: opts.showQuantityRemaining } : {}),
});
const product = await api.getProduct(event.id, created.id);
const priceId = product.prices?.[0]?.id;
if (!priceId) {
throw new Error(`Product ${created.id} has no prices in GET response`);
}
await api.publishEvent(event.id);
return {
eventId: event.id,
slug: event.slug,
title,
productId: created.id,
productTitle: created.title,
priceId,
occurrences,
};
}
export async function createEventWithQuestions(
api: ApiClient,
organizerId: number,
opts: { orderQuestionTitle?: string; attendeeQuestionTitle?: string } = {},
): Promise<SeededEvent & { orderQuestion: QuestionRecord; attendeeQuestion: QuestionRecord }> {
const event = await createLiveEventWithProduct(api, { organizerId, price: 0 });
const orderQuestion = await api.createQuestion(event.eventId, {
title: opts.orderQuestionTitle ?? 'How did you hear about us?',
type: 'SINGLE_LINE_TEXT',
belongs_to: 'ORDER',
product_ids: [],
required: true,
is_hidden: false,
});
const attendeeQuestion = await api.createQuestion(event.eventId, {
title: opts.attendeeQuestionTitle ?? 'Shirt size',
type: 'RADIO',
belongs_to: 'PRODUCT',
product_ids: [event.productId],
options: ['Small', 'Medium', 'Large'],
required: true,
is_hidden: false,
});
return { ...event, orderQuestion, attendeeQuestion };
}
export async function createEventWithAttendee(
api: ApiClient,
organizerId: number,
opts: { attendeeEmail?: string; live?: boolean } = {},
): Promise<SeededEvent & { attendeeEmail: string; attendeeId: number }> {
const event = await createLiveEventWithProduct(api, { organizerId, price: 0 });
const attendeeEmail = opts.attendeeEmail ?? uniqueEmail('attendee');
const attendee = await api.createAttendee(event.eventId, {
product_id: event.productId,
product_price_id: event.priceId,
email: attendeeEmail,
first_name: 'Seeded',
last_name: 'Attendee',
amount_paid: 0,
send_confirmation_email: false,
locale: 'en',
});
return { ...event, attendeeEmail, attendeeId: attendee.id };
}
export function createFreshOrganizer(api: ApiClient, name?: string): Promise<Organizer> {
return api.createOrganizer(name ?? uniqueName('E2E Org'), { email: uniqueEmail('organizer') });
}
export interface SeededBoxOffice {
id: number;
short_id: string;
name: string;
is_system_default: boolean;
has_pin: boolean;
pin: string;
}
export async function defaultBoxOffice(api: ApiClient, eventId: number): Promise<SeededBoxOffice> {
const boxOffices = await api.listBoxOffices(eventId);
const systemDefault = boxOffices.find((boxOffice) => boxOffice.is_system_default);
if (!systemDefault) {
throw new Error(`Event ${eventId} has no system default box office`);
}
return api.resetBoxOfficePin(eventId, systemDefault.id);
}
export async function createDoorSale(
request: APIRequestContext,
boxOffice: SeededBoxOffice,
event: SeededEvent,
opts: { operatorName?: string; quantity?: number; tender?: 'CASH' | 'COMP' | 'OTHER'; amountTendered?: number } = {},
): Promise<DoorOrder> {
const token = await startBoxOfficeSession(request, boxOffice.short_id, {
pin: boxOffice.pin,
operatorName: opts.operatorName ?? 'Sam',
});
const order = await createBoxOfficeOrder(request, boxOffice.short_id, token, [
{ product_id: event.productId, product_price_id: event.priceId, quantity: opts.quantity ?? 1 },
]);
const tender = opts.tender ?? 'CASH';
return tenderBoxOfficeOrder(request, boxOffice.short_id, token, order.short_id, {
tender,
...(tender === 'CASH' ? { amount_tendered: opts.amountTendered ?? order.total_gross } : {}),
...(tender === 'OTHER' ? { reference: 'Paid on SumUp' } : {}),
});
}
export interface SeatedEvent {
eventId: number;
slug: string;
productId: number;
priceId: number;
occurrenceId: number;
}
export type SeatMapFixture = 'theatre' | 'club' | 'empty';
const seatMapFixture = (name: SeatMapFixture) => JSON.parse(
readFileSync(fileURLToPath(new URL(`../../backend/tests/Fixtures/seating/${name}.json`, import.meta.url)), 'utf8'),
);
export async function createFixtureSeatMap(api: ApiClient, organizerId: number, layout: SeatMapFixture, name = 'Main auditorium'): Promise<number> {
return (await api.createSeatMap(organizerId, name, seatMapFixture(layout))).id;
}
export async function attachFixtureSeatMap(
api: ApiClient,
organizerId: number,
eventId: number,
bandProducts: { band_key: string; products: { product_id: number; price_adjustment?: number }[] }[],
layout: 'theatre' | 'club' = 'theatre',
): Promise<void> {
await api.attachSeatMap(eventId, await createFixtureSeatMap(api, organizerId, layout));
await api.linkSeatMapBands(eventId, bandProducts);
}
export async function createSeatedEvent(
api: ApiClient,
organizerId: number,
opts: { layout?: 'theatre' | 'club'; bandKey?: string; price?: number; recurringCount?: number; currency?: string } = {},
): Promise<SeatedEvent & { occurrences: Occurrence[] }> {
const price = opts.price ?? 0;
const event = opts.recurringCount
? await createDraftRecurringEvent(api, organizerId, opts.recurringCount)
: await createDraftEvent(api, organizerId, { currency: opts.currency });
const [category] = await api.listProductCategories(event.eventId);
const product = await api.createProduct(event.eventId, {
title: 'Premium Seat',
product_type: 'TICKET',
type: price > 0 ? 'PAID' : 'FREE',
product_category_id: category.id,
prices: [{ price }],
});
await attachFixtureSeatMap(api, organizerId, event.eventId, [{ band_key: opts.bandKey ?? 'b_premium', products: [{ product_id: product.id }] }], opts.layout);
await api.publishEvent(event.eventId);
const occurrences = [...await api.listOccurrences(event.eventId)].sort((a, b) => a.start_date.localeCompare(b.start_date));
return {
eventId: event.eventId,
slug: event.slug,
productId: product.id,
priceId: product.prices![0].id!,
occurrenceId: occurrences[0].id,
occurrences,
};
}
async function createDraftRecurringEvent(api: ApiClient, organizerId: number, count: number): Promise<{ eventId: number; slug: string }> {
const event = await api.createEvent({
title: uniqueName('E2E Seated Recurring'),
type: 'RECURRING',
organizer_id: organizerId,
start_date: futureStartDate(),
category: 'MUSIC',
currency: 'USD',
timezone: 'UTC',
});
await setAttendeeDetailsCollection(api, event.id, 'PER_TICKET');
await api.generateOccurrences(event.id, {
frequency: 'weekly',
range: { type: 'count', count, start: tomorrowUtcDate() },
days_of_week: ['friday'],
times_of_day: ['19:00'],
duration_minutes: 120,
});
return { eventId: event.id, slug: event.slug };
}
export const createSeatedOrder = (
publicApi: APIRequestContext,
event: SeatedEvent,
seatUids: string[],
opts: Omit<OrderSeedOptions, 'seatUids' | 'quantity'> = {},
): Promise<SeededOrder> => createCompletedOrder(publicApi, event, {
eventOccurrenceId: event.occurrenceId,
...opts,
seatUids,
});