Add landing page
This commit is contained in:
parent
3fea484585
commit
bce86ee840
47 changed files with 7119 additions and 439 deletions
|
|
@ -1,60 +1,75 @@
|
|||
import Series from '../../models/series.js'
|
||||
import Event from '../../models/event.js'
|
||||
import { connectDB } from '../../utils/mongoose.js'
|
||||
import Series from "../../models/series.js";
|
||||
import Event from "../../models/event.js";
|
||||
import { connectDB } from "../../utils/mongoose.js";
|
||||
|
||||
export default defineEventHandler(async (event) => {
|
||||
try {
|
||||
await connectDB()
|
||||
|
||||
await connectDB();
|
||||
|
||||
// Fetch all series
|
||||
const series = await Series.find({ isActive: true })
|
||||
.sort({ createdAt: -1 })
|
||||
.lean()
|
||||
|
||||
.lean();
|
||||
|
||||
// For each series, get event count and statistics
|
||||
const seriesWithStats = await Promise.all(
|
||||
series.map(async (s) => {
|
||||
const events = await Event.find({
|
||||
'series.id': s.id,
|
||||
'series.isSeriesEvent': true
|
||||
}).select('_id startDate endDate registrations').lean()
|
||||
|
||||
const now = new Date()
|
||||
const eventCount = events.length
|
||||
const completedEvents = events.filter(e => e.endDate < now).length
|
||||
const upcomingEvents = events.filter(e => e.startDate > now).length
|
||||
|
||||
const firstEventDate = events.length > 0 ?
|
||||
Math.min(...events.map(e => new Date(e.startDate))) : null
|
||||
const lastEventDate = events.length > 0 ?
|
||||
Math.max(...events.map(e => new Date(e.endDate))) : null
|
||||
|
||||
let status = 'upcoming'
|
||||
const events = await Event.find({
|
||||
"series.id": s.id,
|
||||
"series.isSeriesEvent": true,
|
||||
})
|
||||
.sort({ "series.position": 1, startDate: 1 })
|
||||
.lean();
|
||||
|
||||
const now = new Date();
|
||||
const eventCount = events.length;
|
||||
const completedEvents = events.filter((e) => e.endDate < now).length;
|
||||
const upcomingEvents = events.filter((e) => e.startDate > now).length;
|
||||
|
||||
const firstEventDate =
|
||||
events.length > 0
|
||||
? Math.min(...events.map((e) => new Date(e.startDate)))
|
||||
: null;
|
||||
const lastEventDate =
|
||||
events.length > 0
|
||||
? Math.max(...events.map((e) => new Date(e.endDate)))
|
||||
: null;
|
||||
|
||||
let status = "upcoming";
|
||||
if (lastEventDate && lastEventDate < now) {
|
||||
status = 'completed'
|
||||
} else if (firstEventDate && firstEventDate <= now && lastEventDate && lastEventDate >= now) {
|
||||
status = 'active'
|
||||
status = "completed";
|
||||
} else if (
|
||||
firstEventDate &&
|
||||
firstEventDate <= now &&
|
||||
lastEventDate &&
|
||||
lastEventDate >= now
|
||||
) {
|
||||
status = "active";
|
||||
}
|
||||
|
||||
|
||||
return {
|
||||
...s,
|
||||
events, // Include full event objects
|
||||
eventCount,
|
||||
completedEvents,
|
||||
upcomingEvents,
|
||||
startDate: firstEventDate,
|
||||
endDate: lastEventDate,
|
||||
status,
|
||||
totalRegistrations: events.reduce((sum, e) => sum + (e.registrations?.length || 0), 0)
|
||||
}
|
||||
})
|
||||
)
|
||||
|
||||
return seriesWithStats
|
||||
totalRegistrations: events.reduce(
|
||||
(sum, e) => sum + (e.registrations?.length || 0),
|
||||
0,
|
||||
),
|
||||
};
|
||||
}),
|
||||
);
|
||||
|
||||
return seriesWithStats;
|
||||
} catch (error) {
|
||||
console.error('Error fetching series:', error)
|
||||
console.error("Error fetching series:", error);
|
||||
throw createError({
|
||||
statusCode: 500,
|
||||
statusMessage: 'Failed to fetch series'
|
||||
})
|
||||
statusMessage: "Failed to fetch series",
|
||||
});
|
||||
}
|
||||
})
|
||||
});
|
||||
|
|
|
|||
136
server/api/admin/series/tickets.put.js
Normal file
136
server/api/admin/series/tickets.put.js
Normal file
|
|
@ -0,0 +1,136 @@
|
|||
import Series from '../../../models/series.js'
|
||||
import Event from '../../../models/event.js'
|
||||
import { connectDB } from '../../../utils/mongoose.js'
|
||||
|
||||
export default defineEventHandler(async (event) => {
|
||||
try {
|
||||
await connectDB()
|
||||
|
||||
const body = await readBody(event)
|
||||
const { id, tickets } = body
|
||||
|
||||
if (!id) {
|
||||
throw createError({
|
||||
statusCode: 400,
|
||||
statusMessage: 'Series ID is required'
|
||||
})
|
||||
}
|
||||
|
||||
if (!tickets) {
|
||||
throw createError({
|
||||
statusCode: 400,
|
||||
statusMessage: 'Tickets configuration is required'
|
||||
})
|
||||
}
|
||||
|
||||
// Find the series
|
||||
const series = await Series.findOne({ id })
|
||||
|
||||
if (!series) {
|
||||
throw createError({
|
||||
statusCode: 404,
|
||||
statusMessage: 'Series not found'
|
||||
})
|
||||
}
|
||||
|
||||
// Update the series with new ticketing configuration
|
||||
const updatedSeries = await Series.findOneAndUpdate(
|
||||
{ id },
|
||||
{
|
||||
$set: {
|
||||
tickets: {
|
||||
enabled: tickets.enabled || false,
|
||||
requiresSeriesTicket: tickets.requiresSeriesTicket || false,
|
||||
allowIndividualEventTickets: tickets.allowIndividualEventTickets !== false,
|
||||
currency: tickets.currency || 'CAD',
|
||||
member: {
|
||||
available: tickets.member?.available !== false,
|
||||
isFree: tickets.member?.isFree !== false,
|
||||
price: tickets.member?.price || 0,
|
||||
name: tickets.member?.name || 'Member Series Pass',
|
||||
description: tickets.member?.description || '',
|
||||
circleOverrides: tickets.member?.circleOverrides || {}
|
||||
},
|
||||
public: {
|
||||
available: tickets.public?.available || false,
|
||||
name: tickets.public?.name || 'Series Pass',
|
||||
description: tickets.public?.description || '',
|
||||
price: tickets.public?.price || 0,
|
||||
quantity: tickets.public?.quantity || null,
|
||||
sold: tickets.public?.sold || 0,
|
||||
reserved: tickets.public?.reserved || 0,
|
||||
earlyBirdPrice: tickets.public?.earlyBirdPrice || null,
|
||||
earlyBirdDeadline: tickets.public?.earlyBirdDeadline || null
|
||||
},
|
||||
capacity: {
|
||||
total: tickets.capacity?.total || null,
|
||||
reserved: tickets.capacity?.reserved || 0
|
||||
},
|
||||
waitlist: {
|
||||
enabled: tickets.waitlist?.enabled || false,
|
||||
maxSize: tickets.waitlist?.maxSize || null,
|
||||
entries: tickets.waitlist?.entries || []
|
||||
}
|
||||
},
|
||||
updatedAt: new Date()
|
||||
}
|
||||
},
|
||||
{ new: true }
|
||||
)
|
||||
|
||||
// If requiresSeriesTicket is enabled, update all events in the series
|
||||
if (tickets.enabled && tickets.requiresSeriesTicket) {
|
||||
await Event.updateMany(
|
||||
{
|
||||
'series.id': id,
|
||||
'series.isSeriesEvent': true
|
||||
},
|
||||
{
|
||||
$set: {
|
||||
'tickets.enabled': true,
|
||||
'tickets.requiresSeriesTicket': true,
|
||||
'tickets.seriesTicketReference': updatedSeries._id
|
||||
}
|
||||
}
|
||||
)
|
||||
} else if (tickets.enabled && !tickets.requiresSeriesTicket) {
|
||||
// If series tickets are optional, just mark the reference
|
||||
await Event.updateMany(
|
||||
{
|
||||
'series.id': id,
|
||||
'series.isSeriesEvent': true
|
||||
},
|
||||
{
|
||||
$set: {
|
||||
'tickets.seriesTicketReference': updatedSeries._id
|
||||
}
|
||||
}
|
||||
)
|
||||
} else {
|
||||
// If series tickets are disabled, remove the requirement from events
|
||||
await Event.updateMany(
|
||||
{
|
||||
'series.id': id,
|
||||
'series.isSeriesEvent': true
|
||||
},
|
||||
{
|
||||
$set: {
|
||||
'tickets.requiresSeriesTicket': false,
|
||||
'tickets.seriesTicketReference': null
|
||||
}
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
return {
|
||||
success: true,
|
||||
data: updatedSeries
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('Error updating series ticketing:', error)
|
||||
throw createError({
|
||||
statusCode: error.statusCode || 500,
|
||||
statusMessage: error.statusMessage || 'Failed to update series ticketing'
|
||||
})
|
||||
}
|
||||
})
|
||||
104
server/api/events/[id]/check-series-access.get.js
Normal file
104
server/api/events/[id]/check-series-access.get.js
Normal file
|
|
@ -0,0 +1,104 @@
|
|||
import Event from "../../../models/event.js";
|
||||
import Series from "../../../models/series.js";
|
||||
import { checkUserSeriesPass } from "../../../utils/tickets.js";
|
||||
|
||||
export default defineEventHandler(async (event) => {
|
||||
try {
|
||||
const eventId = getRouterParam(event, "id");
|
||||
const query = getQuery(event);
|
||||
const email = query.email;
|
||||
|
||||
if (!email) {
|
||||
return {
|
||||
hasAccess: false,
|
||||
requiresSeriesPass: false,
|
||||
message: "Email parameter required",
|
||||
};
|
||||
}
|
||||
|
||||
// Fetch event
|
||||
const eventDoc = await Event.findOne({
|
||||
$or: [{ _id: eventId }, { slug: eventId }],
|
||||
});
|
||||
|
||||
if (!eventDoc) {
|
||||
throw createError({
|
||||
statusCode: 404,
|
||||
statusMessage: "Event not found",
|
||||
});
|
||||
}
|
||||
|
||||
// Check if event requires series ticket
|
||||
if (
|
||||
!eventDoc.tickets?.requiresSeriesTicket ||
|
||||
!eventDoc.tickets?.seriesTicketReference
|
||||
) {
|
||||
return {
|
||||
hasAccess: true,
|
||||
requiresSeriesPass: false,
|
||||
message: "Event does not require series pass",
|
||||
};
|
||||
}
|
||||
|
||||
// Fetch the series
|
||||
const series = await Series.findById(
|
||||
eventDoc.tickets.seriesTicketReference,
|
||||
);
|
||||
|
||||
if (!series) {
|
||||
return {
|
||||
hasAccess: false,
|
||||
requiresSeriesPass: true,
|
||||
message: "Series not found",
|
||||
};
|
||||
}
|
||||
|
||||
// Check if user has a valid series pass
|
||||
const { hasPass, registration } = checkUserSeriesPass(series, email);
|
||||
|
||||
if (hasPass) {
|
||||
// Check if already registered for this specific event
|
||||
const eventRegistration = eventDoc.registrations?.find(
|
||||
(reg) =>
|
||||
reg.email.toLowerCase() === email.toLowerCase() && !reg.cancelledAt,
|
||||
);
|
||||
|
||||
return {
|
||||
hasAccess: true,
|
||||
requiresSeriesPass: true,
|
||||
hasSeriesPass: true,
|
||||
alreadyRegistered: !!eventRegistration,
|
||||
registration: registration
|
||||
? {
|
||||
ticketType: registration.ticketType,
|
||||
registeredAt: registration.registeredAt,
|
||||
}
|
||||
: null,
|
||||
series: {
|
||||
id: series.id,
|
||||
title: series.title,
|
||||
slug: series.slug,
|
||||
},
|
||||
message: "Access granted via series pass",
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
hasAccess: false,
|
||||
requiresSeriesPass: true,
|
||||
hasSeriesPass: false,
|
||||
series: {
|
||||
id: series.id,
|
||||
title: series.title,
|
||||
slug: series.slug,
|
||||
},
|
||||
message: "Series pass required for this event",
|
||||
};
|
||||
} catch (error) {
|
||||
console.error("Error checking series access:", error);
|
||||
throw createError({
|
||||
statusCode: error.statusCode || 500,
|
||||
statusMessage: error.statusMessage || "Failed to check series access",
|
||||
});
|
||||
}
|
||||
});
|
||||
155
server/api/events/[id]/tickets/available.get.js
Normal file
155
server/api/events/[id]/tickets/available.get.js
Normal file
|
|
@ -0,0 +1,155 @@
|
|||
import Event from "../../../../models/event.js";
|
||||
import Member from "../../../../models/member.js";
|
||||
import { connectDB } from "../../../../utils/mongoose.js";
|
||||
import {
|
||||
calculateTicketPrice,
|
||||
checkTicketAvailability,
|
||||
formatPrice,
|
||||
} from "../../../../utils/tickets.js";
|
||||
import mongoose from "mongoose";
|
||||
|
||||
/**
|
||||
* GET /api/events/[id]/tickets/available
|
||||
* Check ticket availability and pricing for current user
|
||||
* Query params: ?email=user@example.com (optional)
|
||||
*/
|
||||
export default defineEventHandler(async (event) => {
|
||||
try {
|
||||
await connectDB();
|
||||
const identifier = getRouterParam(event, "id");
|
||||
const query = getQuery(event);
|
||||
const userEmail = query.email;
|
||||
|
||||
if (!identifier) {
|
||||
throw createError({
|
||||
statusCode: 400,
|
||||
statusMessage: "Event identifier is required",
|
||||
});
|
||||
}
|
||||
|
||||
// Fetch the event
|
||||
let eventData;
|
||||
if (mongoose.Types.ObjectId.isValid(identifier)) {
|
||||
eventData = await Event.findById(identifier);
|
||||
}
|
||||
if (!eventData) {
|
||||
eventData = await Event.findOne({ slug: identifier });
|
||||
}
|
||||
|
||||
if (!eventData) {
|
||||
throw createError({
|
||||
statusCode: 404,
|
||||
statusMessage: "Event not found",
|
||||
});
|
||||
}
|
||||
|
||||
// Check if event is cancelled or past
|
||||
if (eventData.isCancelled) {
|
||||
return {
|
||||
available: false,
|
||||
reason: "Event has been cancelled",
|
||||
};
|
||||
}
|
||||
|
||||
if (new Date(eventData.startDate) < new Date()) {
|
||||
return {
|
||||
available: false,
|
||||
reason: "Event has already started",
|
||||
};
|
||||
}
|
||||
|
||||
// Check if user is a member (if email provided)
|
||||
let member = null;
|
||||
if (userEmail) {
|
||||
member = await Member.findOne({ email: userEmail.toLowerCase() });
|
||||
}
|
||||
|
||||
// Calculate ticket pricing for this user
|
||||
const ticketInfo = calculateTicketPrice(eventData, member);
|
||||
|
||||
if (!ticketInfo) {
|
||||
return {
|
||||
available: false,
|
||||
reason: eventData.membersOnly
|
||||
? "This event is for members only"
|
||||
: "No tickets available",
|
||||
membersOnly: eventData.membersOnly,
|
||||
};
|
||||
}
|
||||
|
||||
// Check availability
|
||||
const availability = checkTicketAvailability(
|
||||
eventData,
|
||||
ticketInfo.ticketType
|
||||
);
|
||||
|
||||
// Build response
|
||||
const response = {
|
||||
available: availability.available,
|
||||
ticketType: ticketInfo.ticketType,
|
||||
price: ticketInfo.price,
|
||||
currency: ticketInfo.currency,
|
||||
formattedPrice: formatPrice(ticketInfo.price, ticketInfo.currency),
|
||||
isFree: ticketInfo.isFree,
|
||||
isEarlyBird: ticketInfo.isEarlyBird,
|
||||
name: ticketInfo.name,
|
||||
description: ticketInfo.description,
|
||||
remaining: availability.remaining,
|
||||
waitlistAvailable: availability.waitlistAvailable,
|
||||
};
|
||||
|
||||
// Add early bird deadline if applicable
|
||||
if (
|
||||
ticketInfo.isEarlyBird &&
|
||||
eventData.tickets?.public?.earlyBirdDeadline
|
||||
) {
|
||||
response.earlyBirdDeadline = eventData.tickets.public.earlyBirdDeadline;
|
||||
response.regularPrice = eventData.tickets.public.price;
|
||||
response.formattedRegularPrice = formatPrice(
|
||||
eventData.tickets.public.price,
|
||||
ticketInfo.currency
|
||||
);
|
||||
}
|
||||
|
||||
// Add member vs public comparison for transparency
|
||||
if (member && eventData.tickets?.public?.available) {
|
||||
response.publicTicket = {
|
||||
price: eventData.tickets.public.price,
|
||||
formattedPrice: formatPrice(
|
||||
eventData.tickets.public.price,
|
||||
eventData.tickets.currency
|
||||
),
|
||||
};
|
||||
response.memberSavings =
|
||||
eventData.tickets.public.price - ticketInfo.price;
|
||||
}
|
||||
|
||||
// Check if user is already registered
|
||||
if (userEmail) {
|
||||
const alreadyRegistered = eventData.registrations?.some(
|
||||
(reg) =>
|
||||
reg.email.toLowerCase() === userEmail.toLowerCase() &&
|
||||
!reg.cancelledAt
|
||||
);
|
||||
|
||||
if (alreadyRegistered) {
|
||||
response.alreadyRegistered = true;
|
||||
response.available = false;
|
||||
response.reason = "You are already registered for this event";
|
||||
}
|
||||
}
|
||||
|
||||
return response;
|
||||
} catch (error) {
|
||||
console.error("Error checking ticket availability:", error);
|
||||
|
||||
if (error.statusCode) {
|
||||
throw error;
|
||||
}
|
||||
|
||||
throw createError({
|
||||
statusCode: 500,
|
||||
statusMessage: "Failed to check ticket availability",
|
||||
});
|
||||
}
|
||||
});
|
||||
54
server/api/events/[id]/tickets/check-eligibility.post.js
Normal file
54
server/api/events/[id]/tickets/check-eligibility.post.js
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
import Member from "../../../../models/member.js";
|
||||
import { connectDB } from "../../../../utils/mongoose.js";
|
||||
|
||||
/**
|
||||
* POST /api/events/[id]/tickets/check-eligibility
|
||||
* Check if a user is eligible for member pricing
|
||||
* Body: { email }
|
||||
*/
|
||||
export default defineEventHandler(async (event) => {
|
||||
try {
|
||||
await connectDB();
|
||||
const body = await readBody(event);
|
||||
|
||||
if (!body.email) {
|
||||
throw createError({
|
||||
statusCode: 400,
|
||||
statusMessage: "Email is required",
|
||||
});
|
||||
}
|
||||
|
||||
// Check if user is a member
|
||||
const member = await Member.findOne({
|
||||
email: body.email.toLowerCase(),
|
||||
}).select("email name circle contributionTier");
|
||||
|
||||
if (!member) {
|
||||
return {
|
||||
isMember: false,
|
||||
eligibleForMemberPricing: false,
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
isMember: true,
|
||||
eligibleForMemberPricing: true,
|
||||
memberInfo: {
|
||||
circle: member.circle,
|
||||
tier: member.contributionTier,
|
||||
name: member.name,
|
||||
},
|
||||
};
|
||||
} catch (error) {
|
||||
console.error("Error checking eligibility:", error);
|
||||
|
||||
if (error.statusCode) {
|
||||
throw error;
|
||||
}
|
||||
|
||||
throw createError({
|
||||
statusCode: 500,
|
||||
statusMessage: "Failed to check eligibility",
|
||||
});
|
||||
}
|
||||
});
|
||||
162
server/api/events/[id]/tickets/purchase.post.js
Normal file
162
server/api/events/[id]/tickets/purchase.post.js
Normal file
|
|
@ -0,0 +1,162 @@
|
|||
import Event from "../../../../models/event.js";
|
||||
import Member from "../../../../models/member.js";
|
||||
import { connectDB } from "../../../../utils/mongoose.js";
|
||||
import {
|
||||
validateTicketPurchase,
|
||||
calculateTicketPrice,
|
||||
completeTicketPurchase,
|
||||
} from "../../../../utils/tickets.js";
|
||||
import { sendEventRegistrationEmail } from "../../../../utils/resend.js";
|
||||
import mongoose from "mongoose";
|
||||
|
||||
/**
|
||||
* POST /api/events/[id]/tickets/purchase
|
||||
* Purchase a ticket for an event
|
||||
* Body: { name, email, paymentToken? }
|
||||
*/
|
||||
export default defineEventHandler(async (event) => {
|
||||
try {
|
||||
await connectDB();
|
||||
const identifier = getRouterParam(event, "id");
|
||||
const body = await readBody(event);
|
||||
|
||||
if (!identifier) {
|
||||
throw createError({
|
||||
statusCode: 400,
|
||||
statusMessage: "Event identifier is required",
|
||||
});
|
||||
}
|
||||
|
||||
// Validate required fields
|
||||
if (!body.name || !body.email) {
|
||||
throw createError({
|
||||
statusCode: 400,
|
||||
statusMessage: "Name and email are required",
|
||||
});
|
||||
}
|
||||
|
||||
// Fetch the event
|
||||
let eventData;
|
||||
if (mongoose.Types.ObjectId.isValid(identifier)) {
|
||||
eventData = await Event.findById(identifier);
|
||||
}
|
||||
if (!eventData) {
|
||||
eventData = await Event.findOne({ slug: identifier });
|
||||
}
|
||||
|
||||
if (!eventData) {
|
||||
throw createError({
|
||||
statusCode: 404,
|
||||
statusMessage: "Event not found",
|
||||
});
|
||||
}
|
||||
|
||||
// Check if user is a member
|
||||
const member = await Member.findOne({ email: body.email.toLowerCase() });
|
||||
|
||||
// Validate ticket purchase
|
||||
const validation = validateTicketPurchase(eventData, {
|
||||
email: body.email,
|
||||
name: body.name,
|
||||
member,
|
||||
});
|
||||
|
||||
if (!validation.valid) {
|
||||
throw createError({
|
||||
statusCode: 400,
|
||||
statusMessage: validation.reason,
|
||||
data: {
|
||||
waitlistAvailable: validation.waitlistAvailable,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
const { ticketInfo } = validation;
|
||||
const requiresPayment = ticketInfo.price > 0;
|
||||
|
||||
// Handle payment if required
|
||||
let transactionId = null;
|
||||
if (requiresPayment) {
|
||||
// For HelcimPay.js with purchase type, the transaction is already completed
|
||||
// We just need to verify we received the transaction ID
|
||||
if (!body.transactionId) {
|
||||
throw createError({
|
||||
statusCode: 400,
|
||||
statusMessage:
|
||||
"Transaction ID is required. Payment must be completed first.",
|
||||
});
|
||||
}
|
||||
|
||||
transactionId = body.transactionId;
|
||||
|
||||
// Optional: Verify the transaction with Helcim API
|
||||
// This adds extra security to ensure the transaction is legitimate
|
||||
// For now, we trust the transaction ID from HelcimPay.js
|
||||
console.log("Payment completed with transaction ID:", transactionId);
|
||||
}
|
||||
|
||||
// Create registration
|
||||
const registration = {
|
||||
memberId: member ? member._id : null,
|
||||
name: body.name,
|
||||
email: body.email.toLowerCase(),
|
||||
membershipLevel: member
|
||||
? `${member.circle}-${member.contributionTier}`
|
||||
: "non-member",
|
||||
isMember: !!member,
|
||||
ticketType: ticketInfo.ticketType,
|
||||
ticketPrice: ticketInfo.price,
|
||||
paymentStatus: requiresPayment ? "completed" : "not_required",
|
||||
paymentId: transactionId,
|
||||
amountPaid: ticketInfo.price,
|
||||
registeredAt: new Date(),
|
||||
};
|
||||
|
||||
// Add registration to event
|
||||
eventData.registrations.push(registration);
|
||||
|
||||
// Complete ticket purchase (updates sold/reserved counts)
|
||||
await completeTicketPurchase(eventData, ticketInfo.ticketType);
|
||||
|
||||
// Save event with registration
|
||||
await eventData.save();
|
||||
|
||||
// Send confirmation email
|
||||
try {
|
||||
await sendEventRegistrationEmail(registration, eventData);
|
||||
} catch (emailError) {
|
||||
console.error("Failed to send confirmation email:", emailError);
|
||||
// Don't fail the registration if email fails
|
||||
}
|
||||
|
||||
return {
|
||||
success: true,
|
||||
message: "Ticket purchased successfully!",
|
||||
registration: {
|
||||
id: eventData.registrations[eventData.registrations.length - 1]._id,
|
||||
name: registration.name,
|
||||
email: registration.email,
|
||||
ticketType: registration.ticketType,
|
||||
amountPaid: registration.amountPaid,
|
||||
},
|
||||
payment: transactionId
|
||||
? {
|
||||
transactionId: transactionId,
|
||||
amount: ticketInfo.price,
|
||||
currency: ticketInfo.currency,
|
||||
}
|
||||
: null,
|
||||
};
|
||||
} catch (error) {
|
||||
console.error("Error purchasing ticket:", error);
|
||||
|
||||
if (error.statusCode) {
|
||||
throw error;
|
||||
}
|
||||
|
||||
throw createError({
|
||||
statusCode: 500,
|
||||
statusMessage: "Failed to purchase ticket. Please try again.",
|
||||
});
|
||||
}
|
||||
});
|
||||
94
server/api/events/[id]/tickets/reserve.post.js
Normal file
94
server/api/events/[id]/tickets/reserve.post.js
Normal file
|
|
@ -0,0 +1,94 @@
|
|||
import Event from "../../../../models/event.js";
|
||||
import Member from "../../../../models/member.js";
|
||||
import { connectDB } from "../../../../utils/mongoose.js";
|
||||
import {
|
||||
calculateTicketPrice,
|
||||
reserveTicket,
|
||||
} from "../../../../utils/tickets.js";
|
||||
import mongoose from "mongoose";
|
||||
|
||||
/**
|
||||
* POST /api/events/[id]/tickets/reserve
|
||||
* Temporarily reserve a ticket during checkout process
|
||||
* Body: { email }
|
||||
*/
|
||||
export default defineEventHandler(async (event) => {
|
||||
try {
|
||||
await connectDB();
|
||||
const identifier = getRouterParam(event, "id");
|
||||
const body = await readBody(event);
|
||||
|
||||
if (!identifier) {
|
||||
throw createError({
|
||||
statusCode: 400,
|
||||
statusMessage: "Event identifier is required",
|
||||
});
|
||||
}
|
||||
|
||||
if (!body.email) {
|
||||
throw createError({
|
||||
statusCode: 400,
|
||||
statusMessage: "Email is required",
|
||||
});
|
||||
}
|
||||
|
||||
// Fetch the event
|
||||
let eventData;
|
||||
if (mongoose.Types.ObjectId.isValid(identifier)) {
|
||||
eventData = await Event.findById(identifier);
|
||||
}
|
||||
if (!eventData) {
|
||||
eventData = await Event.findOne({ slug: identifier });
|
||||
}
|
||||
|
||||
if (!eventData) {
|
||||
throw createError({
|
||||
statusCode: 404,
|
||||
statusMessage: "Event not found",
|
||||
});
|
||||
}
|
||||
|
||||
// Check if user is a member
|
||||
const member = await Member.findOne({ email: body.email.toLowerCase() });
|
||||
|
||||
// Calculate ticket type
|
||||
const ticketInfo = calculateTicketPrice(eventData, member);
|
||||
|
||||
if (!ticketInfo) {
|
||||
throw createError({
|
||||
statusCode: 400,
|
||||
statusMessage: "No tickets available for your membership status",
|
||||
});
|
||||
}
|
||||
|
||||
// Reserve the ticket
|
||||
const reservation = await reserveTicket(eventData, ticketInfo.ticketType);
|
||||
|
||||
if (!reservation.success) {
|
||||
throw createError({
|
||||
statusCode: 400,
|
||||
statusMessage: reservation.reason || "Failed to reserve ticket",
|
||||
});
|
||||
}
|
||||
|
||||
return {
|
||||
success: true,
|
||||
reservation: {
|
||||
id: reservation.reservationId,
|
||||
expiresAt: reservation.expiresAt,
|
||||
ticketType: ticketInfo.ticketType,
|
||||
},
|
||||
};
|
||||
} catch (error) {
|
||||
console.error("Error reserving ticket:", error);
|
||||
|
||||
if (error.statusCode) {
|
||||
throw error;
|
||||
}
|
||||
|
||||
throw createError({
|
||||
statusCode: 500,
|
||||
statusMessage: "Failed to reserve ticket",
|
||||
});
|
||||
}
|
||||
});
|
||||
|
|
@ -1,62 +1,86 @@
|
|||
// Initialize HelcimPay.js session
|
||||
const HELCIM_API_BASE = 'https://api.helcim.com/v2'
|
||||
const HELCIM_API_BASE = "https://api.helcim.com/v2";
|
||||
|
||||
export default defineEventHandler(async (event) => {
|
||||
try {
|
||||
const config = useRuntimeConfig(event)
|
||||
const body = await readBody(event)
|
||||
|
||||
const config = useRuntimeConfig(event);
|
||||
const body = await readBody(event);
|
||||
|
||||
// Debug log the request body
|
||||
console.log('Initialize payment request body:', body)
|
||||
|
||||
// Validate required fields
|
||||
if (!body.customerId) {
|
||||
throw createError({
|
||||
statusCode: 400,
|
||||
statusMessage: 'Customer ID is required'
|
||||
})
|
||||
console.log("Initialize payment request body:", body);
|
||||
|
||||
const helcimToken =
|
||||
config.public.helcimToken || process.env.NUXT_PUBLIC_HELCIM_TOKEN;
|
||||
|
||||
// Determine payment type based on whether this is for a subscription or one-time payment
|
||||
const isEventTicket = body.metadata?.type === "event_ticket";
|
||||
const amount = body.amount || 0;
|
||||
|
||||
// For event tickets with amount > 0, we do a purchase
|
||||
// For subscriptions or card verification, we do verify
|
||||
const paymentType = isEventTicket && amount > 0 ? "purchase" : "verify";
|
||||
|
||||
const requestBody = {
|
||||
paymentType,
|
||||
amount: paymentType === "purchase" ? amount : 0,
|
||||
currency: "CAD",
|
||||
paymentMethod: "cc",
|
||||
};
|
||||
|
||||
// For subscription setup (verify mode), include customer code if provided
|
||||
// For one-time purchases (event tickets), don't include customer code
|
||||
// as the customer may not exist in Helcim yet
|
||||
if (body.customerCode && paymentType === "verify") {
|
||||
requestBody.customerCode = body.customerCode;
|
||||
}
|
||||
|
||||
const helcimToken = config.public.helcimToken || process.env.NUXT_PUBLIC_HELCIM_TOKEN
|
||||
|
||||
// Add product/event information for better display in Helcim modal
|
||||
if (body.metadata?.eventTitle) {
|
||||
// Some Helcim accounts don't support invoice numbers in initialization
|
||||
// Try multiple fields that might display in the modal
|
||||
requestBody.description = body.metadata.eventTitle;
|
||||
requestBody.notes = body.metadata.eventTitle;
|
||||
requestBody.orderNumber = `${body.metadata.eventId}`;
|
||||
}
|
||||
|
||||
console.log("Helcim request body:", JSON.stringify(requestBody, null, 2));
|
||||
|
||||
// Initialize HelcimPay.js session
|
||||
const response = await fetch(`${HELCIM_API_BASE}/helcim-pay/initialize`, {
|
||||
method: 'POST',
|
||||
method: "POST",
|
||||
headers: {
|
||||
'accept': 'application/json',
|
||||
'content-type': 'application/json',
|
||||
'api-token': helcimToken
|
||||
accept: "application/json",
|
||||
"content-type": "application/json",
|
||||
"api-token": helcimToken,
|
||||
},
|
||||
body: JSON.stringify({
|
||||
paymentType: 'verify', // For card verification
|
||||
amount: 0, // Must be exactly 0 for verification
|
||||
currency: 'CAD',
|
||||
customerCode: body.customerCode,
|
||||
paymentMethod: 'cc'
|
||||
})
|
||||
})
|
||||
|
||||
body: JSON.stringify(requestBody),
|
||||
});
|
||||
|
||||
if (!response.ok) {
|
||||
const errorText = await response.text()
|
||||
console.error('HelcimPay initialization failed:', response.status, errorText)
|
||||
const errorText = await response.text();
|
||||
console.error(
|
||||
"HelcimPay initialization failed:",
|
||||
response.status,
|
||||
errorText,
|
||||
);
|
||||
throw createError({
|
||||
statusCode: response.status,
|
||||
statusMessage: `Failed to initialize payment: ${errorText}`
|
||||
})
|
||||
statusMessage: `Failed to initialize payment: ${errorText}`,
|
||||
});
|
||||
}
|
||||
|
||||
const paymentData = await response.json()
|
||||
|
||||
const paymentData = await response.json();
|
||||
|
||||
return {
|
||||
success: true,
|
||||
checkoutToken: paymentData.checkoutToken,
|
||||
secretToken: paymentData.secretToken
|
||||
}
|
||||
secretToken: paymentData.secretToken,
|
||||
};
|
||||
} catch (error) {
|
||||
console.error('Error initializing HelcimPay:', error)
|
||||
console.error("Error initializing HelcimPay:", error);
|
||||
throw createError({
|
||||
statusCode: error.statusCode || 500,
|
||||
statusMessage: error.message || 'Failed to initialize payment'
|
||||
})
|
||||
statusMessage: error.message || "Failed to initialize payment",
|
||||
});
|
||||
}
|
||||
})
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1,78 +1,101 @@
|
|||
import Event from '../../models/event.js'
|
||||
import { connectDB } from '../../utils/mongoose.js'
|
||||
import Event from "../../models/event.js";
|
||||
import Series from "../../models/series.js";
|
||||
import { connectDB } from "../../utils/mongoose.js";
|
||||
|
||||
export default defineEventHandler(async (event) => {
|
||||
try {
|
||||
await connectDB()
|
||||
|
||||
const id = getRouterParam(event, 'id')
|
||||
|
||||
await connectDB();
|
||||
|
||||
const id = getRouterParam(event, "id");
|
||||
|
||||
if (!id) {
|
||||
throw createError({
|
||||
statusCode: 400,
|
||||
statusMessage: 'Series ID is required'
|
||||
})
|
||||
statusMessage: "Series ID is required",
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
// Try to fetch the Series model first for full ticketing info
|
||||
// Build query conditions based on whether id looks like ObjectId or string
|
||||
const isObjectId = /^[0-9a-fA-F]{24}$/.test(id);
|
||||
const seriesQuery = isObjectId
|
||||
? { $or: [{ _id: id }, { id: id }, { slug: id }] }
|
||||
: { $or: [{ id: id }, { slug: id }] };
|
||||
|
||||
const seriesModel = await Series.findOne(seriesQuery)
|
||||
.select("-registrations") // Don't expose registration details
|
||||
.lean();
|
||||
|
||||
// Fetch all events in this series
|
||||
const events = await Event.find({
|
||||
'series.id': id,
|
||||
'series.isSeriesEvent': true
|
||||
const events = await Event.find({
|
||||
"series.id": id,
|
||||
"series.isSeriesEvent": true,
|
||||
})
|
||||
.sort({ 'series.position': 1, startDate: 1 })
|
||||
.select('-registrations')
|
||||
.lean()
|
||||
|
||||
if (events.length === 0) {
|
||||
.sort({ "series.position": 1, startDate: 1 })
|
||||
.select("-registrations")
|
||||
.lean();
|
||||
|
||||
if (events.length === 0 && !seriesModel) {
|
||||
throw createError({
|
||||
statusCode: 404,
|
||||
statusMessage: 'Event series not found'
|
||||
})
|
||||
statusMessage: "Event series not found",
|
||||
});
|
||||
}
|
||||
|
||||
// Get series metadata from the first event
|
||||
const seriesInfo = events[0].series
|
||||
|
||||
|
||||
// Get series metadata from the Series model or the first event
|
||||
const seriesInfo = seriesModel || events[0]?.series;
|
||||
|
||||
// Calculate series statistics
|
||||
const now = new Date()
|
||||
const completedEvents = events.filter(e => e.endDate < now).length
|
||||
const upcomingEvents = events.filter(e => e.startDate > now).length
|
||||
const ongoingEvents = events.filter(e => e.startDate <= now && e.endDate >= now).length
|
||||
|
||||
const firstEventDate = events[0].startDate
|
||||
const lastEventDate = events[events.length - 1].endDate
|
||||
|
||||
const now = new Date();
|
||||
const completedEvents = events.filter((e) => e.endDate < now).length;
|
||||
const upcomingEvents = events.filter((e) => e.startDate > now).length;
|
||||
const ongoingEvents = events.filter(
|
||||
(e) => e.startDate <= now && e.endDate >= now,
|
||||
).length;
|
||||
|
||||
const firstEventDate = events[0]?.startDate;
|
||||
const lastEventDate = events[events.length - 1]?.endDate;
|
||||
|
||||
// Return series with additional metadata
|
||||
return {
|
||||
id: id,
|
||||
_id: seriesModel?._id?.toString(),
|
||||
title: seriesInfo.title,
|
||||
description: seriesInfo.description,
|
||||
type: seriesInfo.type,
|
||||
totalEvents: seriesInfo.totalEvents,
|
||||
startDate: firstEventDate,
|
||||
endDate: lastEventDate,
|
||||
events: events.map(e => ({
|
||||
// Include ticketing information if it exists
|
||||
tickets: seriesModel?.tickets || null,
|
||||
events: events.map((e) => ({
|
||||
...e,
|
||||
id: e._id.toString()
|
||||
id: e._id.toString(),
|
||||
})),
|
||||
statistics: {
|
||||
totalEvents: events.length,
|
||||
completedEvents,
|
||||
upcomingEvents,
|
||||
ongoingEvents,
|
||||
isOngoing: firstEventDate <= now && lastEventDate >= now,
|
||||
isUpcoming: firstEventDate > now,
|
||||
isCompleted: lastEventDate < now,
|
||||
totalRegistrations: events.reduce((sum, e) => sum + (e.registrations?.length || 0), 0)
|
||||
}
|
||||
}
|
||||
isOngoing:
|
||||
firstEventDate && lastEventDate
|
||||
? firstEventDate <= now && lastEventDate >= now
|
||||
: false,
|
||||
isUpcoming: firstEventDate ? firstEventDate > now : false,
|
||||
isCompleted: lastEventDate ? lastEventDate < now : false,
|
||||
totalRegistrations: events.reduce(
|
||||
(sum, e) => sum + (e.registrations?.length || 0),
|
||||
0,
|
||||
),
|
||||
},
|
||||
};
|
||||
} catch (error) {
|
||||
console.error('Error fetching event series:', error)
|
||||
if (error.statusCode) throw error
|
||||
|
||||
console.error("Error fetching event series:", error);
|
||||
if (error.statusCode) throw error;
|
||||
|
||||
throw createError({
|
||||
statusCode: 500,
|
||||
statusMessage: 'Failed to fetch event series'
|
||||
})
|
||||
statusMessage: "Failed to fetch event series",
|
||||
});
|
||||
}
|
||||
})
|
||||
});
|
||||
|
|
|
|||
118
server/api/series/[id]/tickets/available.get.js
Normal file
118
server/api/series/[id]/tickets/available.get.js
Normal file
|
|
@ -0,0 +1,118 @@
|
|||
import Series from "../../../../models/series.js";
|
||||
import Member from "../../../../models/member.js";
|
||||
import {
|
||||
calculateSeriesTicketPrice,
|
||||
checkSeriesTicketAvailability,
|
||||
checkUserSeriesPass,
|
||||
} from "../../../../utils/tickets.js";
|
||||
|
||||
export default defineEventHandler(async (event) => {
|
||||
try {
|
||||
const seriesId = getRouterParam(event, "id");
|
||||
const query = getQuery(event);
|
||||
const email = query.email;
|
||||
|
||||
// Fetch series
|
||||
// Build query conditions based on whether seriesId looks like ObjectId or string
|
||||
const isObjectId = /^[0-9a-fA-F]{24}$/.test(seriesId);
|
||||
const seriesQuery = isObjectId
|
||||
? { $or: [{ _id: seriesId }, { id: seriesId }, { slug: seriesId }] }
|
||||
: { $or: [{ id: seriesId }, { slug: seriesId }] };
|
||||
|
||||
const series = await Series.findOne(seriesQuery);
|
||||
|
||||
if (!series) {
|
||||
throw createError({
|
||||
statusCode: 404,
|
||||
statusMessage: "Series not found",
|
||||
});
|
||||
}
|
||||
|
||||
// Check if tickets are enabled
|
||||
if (!series.tickets?.enabled) {
|
||||
return {
|
||||
available: false,
|
||||
message: "Tickets are not enabled for this series",
|
||||
};
|
||||
}
|
||||
|
||||
// Check membership if email provided
|
||||
let member = null;
|
||||
|
||||
if (email) {
|
||||
member = await Member.findOne({ email: email.toLowerCase() });
|
||||
}
|
||||
|
||||
// Check if user already has a series pass
|
||||
const { hasPass, registration } = checkUserSeriesPass(series, email || "");
|
||||
|
||||
if (hasPass) {
|
||||
return {
|
||||
available: false,
|
||||
alreadyRegistered: true,
|
||||
registration: {
|
||||
ticketType: registration.ticketType,
|
||||
registeredAt: registration.registeredAt,
|
||||
eventsIncluded: registration.eventRegistrations?.length || 0,
|
||||
},
|
||||
message: "You already have a pass for this series",
|
||||
};
|
||||
}
|
||||
|
||||
// Calculate pricing for user
|
||||
const ticketInfo = calculateSeriesTicketPrice(series, member);
|
||||
|
||||
if (!ticketInfo) {
|
||||
return {
|
||||
available: false,
|
||||
message: "No series passes available for your membership status",
|
||||
};
|
||||
}
|
||||
|
||||
// Check availability
|
||||
const availability = checkSeriesTicketAvailability(
|
||||
series,
|
||||
ticketInfo.ticketType,
|
||||
);
|
||||
|
||||
return {
|
||||
available: availability.available,
|
||||
ticket: {
|
||||
type: ticketInfo.ticketType,
|
||||
name: ticketInfo.name,
|
||||
description: ticketInfo.description,
|
||||
price: ticketInfo.price,
|
||||
currency: ticketInfo.currency,
|
||||
isFree: ticketInfo.isFree,
|
||||
isEarlyBird: ticketInfo.isEarlyBird,
|
||||
},
|
||||
availability: {
|
||||
remaining: availability.remaining,
|
||||
unlimited: availability.remaining === null,
|
||||
waitlistAvailable: availability.waitlistAvailable,
|
||||
},
|
||||
series: {
|
||||
id: series.id,
|
||||
title: series.title,
|
||||
totalEvents: series.totalEvents,
|
||||
type: series.type,
|
||||
},
|
||||
memberInfo: member
|
||||
? {
|
||||
isMember: true,
|
||||
circle: member.circle,
|
||||
name: member.name,
|
||||
}
|
||||
: {
|
||||
isMember: false,
|
||||
},
|
||||
};
|
||||
} catch (error) {
|
||||
console.error("Error checking series ticket availability:", error);
|
||||
throw createError({
|
||||
statusCode: error.statusCode || 500,
|
||||
statusMessage:
|
||||
error.statusMessage || "Failed to check series ticket availability",
|
||||
});
|
||||
}
|
||||
});
|
||||
38
server/api/series/[id]/tickets/check-eligibility.post.js
Normal file
38
server/api/series/[id]/tickets/check-eligibility.post.js
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
import Member from "../../../../models/member.js";
|
||||
|
||||
export default defineEventHandler(async (event) => {
|
||||
try {
|
||||
const body = await readBody(event);
|
||||
const { email } = body;
|
||||
|
||||
if (!email) {
|
||||
return {
|
||||
isMember: false,
|
||||
message: "Email is required",
|
||||
};
|
||||
}
|
||||
|
||||
const member = await Member.findOne({ email: email.toLowerCase() });
|
||||
|
||||
if (!member) {
|
||||
return {
|
||||
isMember: false,
|
||||
message: "No membership found",
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
isMember: true,
|
||||
circle: member.circle,
|
||||
name: member.name,
|
||||
email: member.email,
|
||||
message: "Member eligibility confirmed",
|
||||
};
|
||||
} catch (error) {
|
||||
console.error("Error checking series ticket eligibility:", error);
|
||||
throw createError({
|
||||
statusCode: 500,
|
||||
statusMessage: "Failed to check member eligibility",
|
||||
});
|
||||
}
|
||||
});
|
||||
163
server/api/series/[id]/tickets/purchase.post.js
Normal file
163
server/api/series/[id]/tickets/purchase.post.js
Normal file
|
|
@ -0,0 +1,163 @@
|
|||
import Series from "../../../../models/series.js";
|
||||
import Event from "../../../../models/event.js";
|
||||
import Member from "../../../../models/member.js";
|
||||
import {
|
||||
validateSeriesTicketPurchase,
|
||||
calculateSeriesTicketPrice,
|
||||
reserveSeriesTicket,
|
||||
releaseSeriesTicket,
|
||||
completeSeriesTicketPurchase,
|
||||
registerForAllSeriesEvents,
|
||||
} from "../../../../utils/tickets.js";
|
||||
import { sendSeriesPassConfirmation } from "../../../../utils/resend.js";
|
||||
|
||||
export default defineEventHandler(async (event) => {
|
||||
try {
|
||||
const seriesId = getRouterParam(event, "id");
|
||||
const body = await readBody(event);
|
||||
const { name, email, paymentId } = body;
|
||||
|
||||
// Validate input
|
||||
if (!name || !email) {
|
||||
throw createError({
|
||||
statusCode: 400,
|
||||
statusMessage: "Name and email are required",
|
||||
});
|
||||
}
|
||||
|
||||
// Fetch series
|
||||
// Build query conditions based on whether seriesId looks like ObjectId or string
|
||||
const isObjectId = /^[0-9a-fA-F]{24}$/.test(seriesId);
|
||||
const seriesQuery = isObjectId
|
||||
? { $or: [{ _id: seriesId }, { id: seriesId }, { slug: seriesId }] }
|
||||
: { $or: [{ id: seriesId }, { slug: seriesId }] };
|
||||
|
||||
const series = await Series.findOne(seriesQuery);
|
||||
|
||||
if (!series) {
|
||||
throw createError({
|
||||
statusCode: 404,
|
||||
statusMessage: "Series not found",
|
||||
});
|
||||
}
|
||||
|
||||
// Check membership
|
||||
let member = null;
|
||||
member = await Member.findOne({ email: email.toLowerCase() });
|
||||
|
||||
// Validate purchase
|
||||
const validation = validateSeriesTicketPurchase(series, {
|
||||
email,
|
||||
name,
|
||||
member,
|
||||
});
|
||||
|
||||
if (!validation.valid) {
|
||||
throw createError({
|
||||
statusCode: 400,
|
||||
statusMessage: validation.reason,
|
||||
});
|
||||
}
|
||||
|
||||
const { ticketInfo } = validation;
|
||||
|
||||
// For paid tickets, require payment ID
|
||||
if (!ticketInfo.isFree && !paymentId) {
|
||||
throw createError({
|
||||
statusCode: 400,
|
||||
statusMessage: "Payment is required for this series pass",
|
||||
});
|
||||
}
|
||||
|
||||
// Create series registration
|
||||
const registration = {
|
||||
memberId: member?._id,
|
||||
name,
|
||||
email: email.toLowerCase(),
|
||||
membershipLevel: member?.circle || "non-member",
|
||||
isMember: !!member,
|
||||
ticketType: ticketInfo.ticketType,
|
||||
ticketPrice: ticketInfo.price,
|
||||
paymentStatus: ticketInfo.isFree ? "not_required" : "completed",
|
||||
paymentId: paymentId || null,
|
||||
amountPaid: ticketInfo.price,
|
||||
registeredAt: new Date(),
|
||||
eventRegistrations: [],
|
||||
};
|
||||
|
||||
series.registrations.push(registration);
|
||||
await completeSeriesTicketPurchase(series, ticketInfo.ticketType);
|
||||
|
||||
// Get the newly created registration
|
||||
const newRegistration =
|
||||
series.registrations[series.registrations.length - 1];
|
||||
|
||||
// Fetch all events in this series
|
||||
const seriesEvents = await Event.find({
|
||||
"series.id": series.id,
|
||||
isCancelled: false,
|
||||
}).sort({ "series.position": 1, startDate: 1 });
|
||||
|
||||
// Register user for all events
|
||||
const eventRegistrations = await registerForAllSeriesEvents(
|
||||
series,
|
||||
seriesEvents,
|
||||
newRegistration,
|
||||
);
|
||||
|
||||
// Send confirmation email
|
||||
try {
|
||||
await sendSeriesPassConfirmation({
|
||||
to: email,
|
||||
name,
|
||||
series: {
|
||||
title: series.title,
|
||||
description: series.description,
|
||||
type: series.type,
|
||||
},
|
||||
ticket: {
|
||||
type: ticketInfo.ticketType,
|
||||
price: ticketInfo.price,
|
||||
currency: ticketInfo.currency,
|
||||
isFree: ticketInfo.isFree,
|
||||
},
|
||||
events: seriesEvents.map((e) => ({
|
||||
title: e.title,
|
||||
startDate: e.startDate,
|
||||
endDate: e.endDate,
|
||||
location: e.location,
|
||||
})),
|
||||
paymentId,
|
||||
});
|
||||
} catch (emailError) {
|
||||
console.error(
|
||||
"Failed to send series pass confirmation email:",
|
||||
emailError,
|
||||
);
|
||||
// Don't fail the registration if email fails
|
||||
}
|
||||
|
||||
return {
|
||||
success: true,
|
||||
message: "Series pass purchased successfully",
|
||||
registration: {
|
||||
id: newRegistration._id,
|
||||
ticketType: newRegistration.ticketType,
|
||||
amountPaid: newRegistration.amountPaid,
|
||||
eventsRegistered: eventRegistrations.filter((r) => r.success).length,
|
||||
totalEvents: seriesEvents.length,
|
||||
},
|
||||
events: eventRegistrations.map((r) => ({
|
||||
eventId: r.eventId,
|
||||
success: r.success,
|
||||
reason: r.reason,
|
||||
})),
|
||||
};
|
||||
} catch (error) {
|
||||
console.error("Error purchasing series pass:", error);
|
||||
throw createError({
|
||||
statusCode: error.statusCode || 500,
|
||||
statusMessage: error.statusMessage || "Failed to purchase series pass",
|
||||
});
|
||||
}
|
||||
});
|
||||
|
|
@ -70,16 +70,66 @@ const eventSchema = new mongoose.Schema({
|
|||
// Ticket configuration
|
||||
tickets: {
|
||||
enabled: { type: Boolean, default: false },
|
||||
requiresSeriesTicket: { type: Boolean, default: false }, // If true, must buy series pass instead
|
||||
seriesTicketReference: {
|
||||
type: mongoose.Schema.Types.ObjectId,
|
||||
ref: "Series",
|
||||
}, // Reference to series with tickets
|
||||
currency: { type: String, default: "CAD" },
|
||||
// Member ticket configuration
|
||||
member: {
|
||||
available: { type: Boolean, default: true }, // Members can always register if tickets enabled
|
||||
isFree: { type: Boolean, default: true }, // Most events free for members
|
||||
price: { type: Number, default: 0 }, // Optional member price (discounted)
|
||||
name: { type: String, default: "Member Ticket" },
|
||||
description: String,
|
||||
// Circle-specific overrides (optional)
|
||||
circleOverrides: {
|
||||
community: {
|
||||
isFree: { type: Boolean },
|
||||
price: { type: Number },
|
||||
},
|
||||
founder: {
|
||||
isFree: { type: Boolean },
|
||||
price: { type: Number },
|
||||
},
|
||||
practitioner: {
|
||||
isFree: { type: Boolean },
|
||||
price: { type: Number },
|
||||
},
|
||||
},
|
||||
},
|
||||
// Public (non-member) ticket configuration
|
||||
public: {
|
||||
available: { type: Boolean, default: false },
|
||||
name: { type: String, default: "Public Ticket" },
|
||||
description: String,
|
||||
price: { type: Number, default: 0 },
|
||||
quantity: Number, // null = unlimited
|
||||
quantity: Number, // null/undefined = unlimited
|
||||
sold: { type: Number, default: 0 },
|
||||
reserved: { type: Number, default: 0 }, // Temporarily reserved during checkout
|
||||
earlyBirdPrice: Number,
|
||||
earlyBirdDeadline: Date,
|
||||
},
|
||||
// Capacity management (applies to all ticket types combined)
|
||||
capacity: {
|
||||
total: Number, // null/undefined = unlimited
|
||||
reserved: { type: Number, default: 0 }, // Currently reserved across all types
|
||||
},
|
||||
// Waitlist configuration
|
||||
waitlist: {
|
||||
enabled: { type: Boolean, default: false },
|
||||
maxSize: Number, // null = unlimited waitlist
|
||||
entries: [
|
||||
{
|
||||
name: String,
|
||||
email: String,
|
||||
membershipLevel: String,
|
||||
addedAt: { type: Date, default: Date.now },
|
||||
notified: { type: Boolean, default: false },
|
||||
},
|
||||
],
|
||||
},
|
||||
},
|
||||
// Circle targeting
|
||||
targetCircles: [
|
||||
|
|
@ -107,14 +157,29 @@ const eventSchema = new mongoose.Schema({
|
|||
email: String,
|
||||
membershipLevel: String,
|
||||
isMember: { type: Boolean, default: false },
|
||||
// Ticket information
|
||||
ticketType: {
|
||||
type: String,
|
||||
enum: ["member", "public", "guest", "series_pass"],
|
||||
default: "guest",
|
||||
},
|
||||
ticketPrice: { type: Number, default: 0 }, // Actual price paid (may be early bird, member, etc.)
|
||||
// Series ticket info
|
||||
isSeriesTicketHolder: { type: Boolean, default: false }, // Registered via series pass
|
||||
seriesTicketId: { type: mongoose.Schema.Types.ObjectId, ref: "Series" }, // Reference to series registration
|
||||
// Payment information
|
||||
paymentStatus: {
|
||||
type: String,
|
||||
enum: ["pending", "completed", "failed", "not_required"],
|
||||
enum: ["pending", "completed", "failed", "refunded", "not_required"],
|
||||
default: "not_required",
|
||||
},
|
||||
paymentId: String, // Helcim transaction ID
|
||||
amountPaid: { type: Number, default: 0 },
|
||||
// Metadata
|
||||
registeredAt: { type: Date, default: Date.now },
|
||||
cancelledAt: Date,
|
||||
refundedAt: Date,
|
||||
refundAmount: Number,
|
||||
},
|
||||
],
|
||||
createdBy: { type: String, required: true },
|
||||
|
|
|
|||
|
|
@ -1,35 +1,173 @@
|
|||
import mongoose from 'mongoose'
|
||||
import mongoose from "mongoose";
|
||||
|
||||
const seriesSchema = new mongoose.Schema({
|
||||
id: {
|
||||
type: String,
|
||||
required: true,
|
||||
unique: true,
|
||||
validate: {
|
||||
validator: function(v) {
|
||||
return /^[a-z0-9-]+$/.test(v);
|
||||
},
|
||||
message: 'Series ID must contain only lowercase letters, numbers, and dashes'
|
||||
}
|
||||
},
|
||||
id: { type: String, required: true, unique: true }, // Simple string ID (e.g., "coop-game-dev-2025")
|
||||
title: { type: String, required: true },
|
||||
description: { type: String, required: true },
|
||||
slug: { type: String, unique: true }, // Auto-generated in pre-save hook
|
||||
description: String,
|
||||
type: {
|
||||
type: String,
|
||||
enum: ['workshop_series', 'recurring_meetup', 'multi_day', 'course', 'tournament'],
|
||||
default: 'workshop_series'
|
||||
enum: [
|
||||
"workshop_series",
|
||||
"recurring_meetup",
|
||||
"multi_day",
|
||||
"course",
|
||||
"tournament",
|
||||
],
|
||||
default: "workshop_series",
|
||||
},
|
||||
totalEvents: Number,
|
||||
// Visibility and status
|
||||
isVisible: { type: Boolean, default: true },
|
||||
isActive: { type: Boolean, default: true },
|
||||
// Date range (calculated from events or set manually)
|
||||
startDate: Date,
|
||||
endDate: Date,
|
||||
// Series ticketing configuration
|
||||
tickets: {
|
||||
enabled: { type: Boolean, default: false },
|
||||
requiresSeriesTicket: { type: Boolean, default: false }, // If true, must buy series pass
|
||||
allowIndividualEventTickets: { type: Boolean, default: true }, // Allow drop-in for individual events
|
||||
currency: { type: String, default: "CAD" },
|
||||
// Member series pass configuration
|
||||
member: {
|
||||
available: { type: Boolean, default: true },
|
||||
isFree: { type: Boolean, default: true },
|
||||
price: { type: Number, default: 0 },
|
||||
name: { type: String, default: "Member Series Pass" },
|
||||
description: String,
|
||||
// Circle-specific overrides
|
||||
circleOverrides: {
|
||||
community: {
|
||||
isFree: { type: Boolean },
|
||||
price: { type: Number },
|
||||
},
|
||||
founder: {
|
||||
isFree: { type: Boolean },
|
||||
price: { type: Number },
|
||||
},
|
||||
practitioner: {
|
||||
isFree: { type: Boolean },
|
||||
price: { type: Number },
|
||||
},
|
||||
},
|
||||
},
|
||||
// Public (non-member) series pass configuration
|
||||
public: {
|
||||
available: { type: Boolean, default: false },
|
||||
name: { type: String, default: "Series Pass" },
|
||||
description: String,
|
||||
price: { type: Number, default: 0 },
|
||||
quantity: Number, // null/undefined = unlimited
|
||||
sold: { type: Number, default: 0 },
|
||||
reserved: { type: Number, default: 0 },
|
||||
earlyBirdPrice: Number,
|
||||
earlyBirdDeadline: Date,
|
||||
},
|
||||
// Series-wide capacity
|
||||
capacity: {
|
||||
total: Number, // null/undefined = unlimited
|
||||
reserved: { type: Number, default: 0 },
|
||||
},
|
||||
// Waitlist configuration
|
||||
waitlist: {
|
||||
enabled: { type: Boolean, default: false },
|
||||
maxSize: Number,
|
||||
entries: [
|
||||
{
|
||||
name: String,
|
||||
email: String,
|
||||
membershipLevel: String,
|
||||
addedAt: { type: Date, default: Date.now },
|
||||
notified: { type: Boolean, default: false },
|
||||
},
|
||||
],
|
||||
},
|
||||
},
|
||||
// Series pass purchases (registrations)
|
||||
registrations: [
|
||||
{
|
||||
memberId: { type: mongoose.Schema.Types.ObjectId, ref: "Member" },
|
||||
name: String,
|
||||
email: String,
|
||||
membershipLevel: String,
|
||||
isMember: { type: Boolean, default: false },
|
||||
// Ticket information
|
||||
ticketType: {
|
||||
type: String,
|
||||
enum: ["member", "public", "guest"],
|
||||
default: "guest",
|
||||
},
|
||||
ticketPrice: { type: Number, default: 0 },
|
||||
// Payment information
|
||||
paymentStatus: {
|
||||
type: String,
|
||||
enum: ["pending", "completed", "failed", "refunded", "not_required"],
|
||||
default: "not_required",
|
||||
},
|
||||
paymentId: String, // Helcim transaction ID
|
||||
amountPaid: { type: Number, default: 0 },
|
||||
// Metadata
|
||||
registeredAt: { type: Date, default: Date.now },
|
||||
cancelledAt: Date,
|
||||
refundedAt: Date,
|
||||
refundAmount: Number,
|
||||
// Events they've been registered for (references)
|
||||
eventRegistrations: [
|
||||
{
|
||||
eventId: { type: mongoose.Schema.Types.ObjectId, ref: "Event" },
|
||||
registrationId: mongoose.Schema.Types.ObjectId, // ID of registration in event.registrations
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
// Target circles
|
||||
targetCircles: [
|
||||
{
|
||||
type: String,
|
||||
enum: ["community", "founder", "practitioner"],
|
||||
},
|
||||
],
|
||||
// Metadata
|
||||
totalEvents: { type: Number, default: 0 }, // Number of events in this series
|
||||
createdBy: { type: String, required: true },
|
||||
createdAt: { type: Date, default: Date.now },
|
||||
updatedAt: { type: Date, default: Date.now }
|
||||
})
|
||||
updatedAt: { type: Date, default: Date.now },
|
||||
});
|
||||
|
||||
// Update the updatedAt field on save
|
||||
seriesSchema.pre('save', function(next) {
|
||||
this.updatedAt = new Date()
|
||||
next()
|
||||
})
|
||||
// Generate slug from title
|
||||
function generateSlug(title) {
|
||||
return title
|
||||
.toLowerCase()
|
||||
.replace(/[^a-z0-9]+/g, "-")
|
||||
.replace(/^-+|-+$/g, "");
|
||||
}
|
||||
|
||||
export default mongoose.models.Series || mongoose.model('Series', seriesSchema)
|
||||
// Pre-save hook to generate slug
|
||||
seriesSchema.pre("save", async function (next) {
|
||||
try {
|
||||
// Always generate slug if it doesn't exist or if title has changed
|
||||
if (!this.slug || this.isNew || this.isModified("title")) {
|
||||
let baseSlug = generateSlug(this.title);
|
||||
let slug = baseSlug;
|
||||
let counter = 1;
|
||||
|
||||
// Ensure slug is unique
|
||||
while (await this.constructor.findOne({ slug, _id: { $ne: this._id } })) {
|
||||
slug = `${baseSlug}-${counter}`;
|
||||
counter++;
|
||||
}
|
||||
|
||||
this.slug = slug;
|
||||
}
|
||||
|
||||
// Update timestamps
|
||||
this.updatedAt = new Date();
|
||||
|
||||
next();
|
||||
} catch (error) {
|
||||
console.error("Error in pre-save hook:", error);
|
||||
next(error);
|
||||
}
|
||||
});
|
||||
|
||||
export default mongoose.models.Series || mongoose.model("Series", seriesSchema);
|
||||
|
|
|
|||
|
|
@ -128,6 +128,45 @@ export async function sendEventRegistrationEmail(registration, eventData) {
|
|||
|
||||
${eventData.description ? `<p>${eventData.description}</p>` : ""}
|
||||
|
||||
${
|
||||
registration.ticketType &&
|
||||
registration.ticketType !== "guest" &&
|
||||
registration.amountPaid > 0
|
||||
? `
|
||||
<div class="event-details" style="margin-top: 20px;">
|
||||
<h3 style="margin-top: 0; color: #1a1a2e;">Ticket Information</h3>
|
||||
<div class="detail-row">
|
||||
<div class="label">Ticket Type</div>
|
||||
<div class="value">${registration.ticketType === "member" ? "Member Ticket" : "Public Ticket"}</div>
|
||||
</div>
|
||||
<div class="detail-row">
|
||||
<div class="label">Amount Paid</div>
|
||||
<div class="value">$${registration.amountPaid.toFixed(2)} CAD</div>
|
||||
</div>
|
||||
${
|
||||
registration.paymentId
|
||||
? `
|
||||
<div class="detail-row">
|
||||
<div class="label">Transaction ID</div>
|
||||
<div class="value" style="font-size: 12px; font-family: monospace;">${registration.paymentId}</div>
|
||||
</div>
|
||||
`
|
||||
: ""
|
||||
}
|
||||
</div>
|
||||
`
|
||||
: registration.ticketType === "member" &&
|
||||
registration.amountPaid === 0
|
||||
? `
|
||||
<div style="background-color: #e0e7ff; border-left: 4px solid #6366f1; padding: 15px; border-radius: 4px; margin: 20px 0;">
|
||||
<p style="margin: 0; color: #4338ca;">
|
||||
<strong>✨ Member Benefit:</strong> This event is free for Ghost Guild members!
|
||||
</p>
|
||||
</div>
|
||||
`
|
||||
: ""
|
||||
}
|
||||
|
||||
<center>
|
||||
<a href="${process.env.BASE_URL || "https://ghostguild.org"}/events/${eventData.slug || eventData._id}" class="button">
|
||||
View Event Details
|
||||
|
|
@ -261,3 +300,282 @@ export async function sendEventCancellationEmail(registration, eventData) {
|
|||
return { success: false, error };
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Send series pass confirmation email
|
||||
*/
|
||||
export async function sendSeriesPassConfirmation(options) {
|
||||
const { to, name, series, ticket, events, paymentId } = options;
|
||||
|
||||
const formatDate = (dateString) => {
|
||||
const date = new Date(dateString);
|
||||
return new Intl.DateTimeFormat("en-US", {
|
||||
weekday: "long",
|
||||
year: "numeric",
|
||||
month: "long",
|
||||
day: "numeric",
|
||||
}).format(date);
|
||||
};
|
||||
|
||||
const formatTime = (startDate, endDate) => {
|
||||
const start = new Date(startDate);
|
||||
const end = new Date(endDate);
|
||||
|
||||
const timeFormat = new Intl.DateTimeFormat("en-US", {
|
||||
hour: "numeric",
|
||||
minute: "2-digit",
|
||||
timeZoneName: "short",
|
||||
});
|
||||
|
||||
return `${timeFormat.format(start)} - ${timeFormat.format(end)}`;
|
||||
};
|
||||
|
||||
const formatPrice = (price, currency = "CAD") => {
|
||||
if (price === 0) return "Free";
|
||||
return new Intl.NumberFormat("en-CA", {
|
||||
style: "currency",
|
||||
currency,
|
||||
}).format(price);
|
||||
};
|
||||
|
||||
const seriesTypeLabels = {
|
||||
workshop_series: "Workshop Series",
|
||||
recurring_meetup: "Recurring Meetup",
|
||||
multi_day: "Multi-Day Event",
|
||||
course: "Course",
|
||||
tournament: "Tournament",
|
||||
};
|
||||
|
||||
try {
|
||||
const { data, error } = await resend.emails.send({
|
||||
from: "Ghost Guild <events@babyghosts.org>",
|
||||
to: [to],
|
||||
subject: `Your Series Pass for ${series.title}`,
|
||||
html: `
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||||
<style>
|
||||
body {
|
||||
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
|
||||
line-height: 1.6;
|
||||
color: #333;
|
||||
max-width: 600px;
|
||||
margin: 0 auto;
|
||||
padding: 20px;
|
||||
}
|
||||
.header {
|
||||
background: linear-gradient(135deg, #7c3aed 0%, #5b21b6 100%);
|
||||
color: #fff;
|
||||
padding: 30px;
|
||||
text-align: center;
|
||||
border-radius: 8px 8px 0 0;
|
||||
}
|
||||
.content {
|
||||
background-color: #f9f9f9;
|
||||
padding: 30px;
|
||||
border-radius: 0 0 8px 8px;
|
||||
}
|
||||
.pass-details {
|
||||
background-color: #fff;
|
||||
padding: 20px;
|
||||
border-radius: 8px;
|
||||
margin: 20px 0;
|
||||
border-left: 4px solid #7c3aed;
|
||||
}
|
||||
.event-list {
|
||||
background-color: #fff;
|
||||
padding: 20px;
|
||||
border-radius: 8px;
|
||||
margin: 20px 0;
|
||||
}
|
||||
.event-item {
|
||||
padding: 15px;
|
||||
margin: 10px 0;
|
||||
background-color: #f9f9f9;
|
||||
border-radius: 6px;
|
||||
border-left: 3px solid #7c3aed;
|
||||
}
|
||||
.detail-row {
|
||||
margin: 10px 0;
|
||||
}
|
||||
.label {
|
||||
font-weight: 600;
|
||||
color: #666;
|
||||
font-size: 14px;
|
||||
}
|
||||
.value {
|
||||
color: #1a1a2e;
|
||||
font-size: 16px;
|
||||
}
|
||||
.member-benefit {
|
||||
background-color: #dcfce7;
|
||||
border: 2px solid #86efac;
|
||||
padding: 15px;
|
||||
border-radius: 8px;
|
||||
margin: 20px 0;
|
||||
}
|
||||
.footer {
|
||||
text-align: center;
|
||||
padding: 20px;
|
||||
color: #666;
|
||||
font-size: 14px;
|
||||
}
|
||||
.button {
|
||||
display: inline-block;
|
||||
background-color: #7c3aed;
|
||||
color: #fff;
|
||||
padding: 12px 24px;
|
||||
text-decoration: none;
|
||||
border-radius: 6px;
|
||||
margin: 10px 0;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<div class="header">
|
||||
<h1 style="margin: 0; font-size: 28px;">🎫 Your Series Pass is Ready!</h1>
|
||||
<p style="margin: 10px 0 0 0; opacity: 0.9;">You're registered for all events</p>
|
||||
</div>
|
||||
|
||||
<div class="content">
|
||||
<p style="font-size: 18px; margin-bottom: 10px;">Hi ${name},</p>
|
||||
|
||||
<p>
|
||||
Great news! Your series pass for <strong>${series.title}</strong> is confirmed.
|
||||
You're now registered for all ${events.length} events in this ${seriesTypeLabels[series.type] || "series"}.
|
||||
</p>
|
||||
|
||||
${
|
||||
ticket.isFree && ticket.type === "member"
|
||||
? `
|
||||
<div class="member-benefit">
|
||||
<p style="margin: 0; font-weight: 600; color: #166534;">
|
||||
✨ Member Benefit
|
||||
</p>
|
||||
<p style="margin: 5px 0 0 0; color: #166534;">
|
||||
This series pass is free for Ghost Guild members. Thank you for being part of our community!
|
||||
</p>
|
||||
</div>
|
||||
`
|
||||
: ""
|
||||
}
|
||||
|
||||
<div class="pass-details">
|
||||
<h2 style="margin: 0 0 15px 0; color: #7c3aed; font-size: 20px;">Series Pass Details</h2>
|
||||
|
||||
<div class="detail-row">
|
||||
<div class="label">Series</div>
|
||||
<div class="value">${series.title}</div>
|
||||
</div>
|
||||
|
||||
${
|
||||
series.description
|
||||
? `
|
||||
<div class="detail-row">
|
||||
<div class="label">About</div>
|
||||
<div class="value">${series.description}</div>
|
||||
</div>
|
||||
`
|
||||
: ""
|
||||
}
|
||||
|
||||
<div class="detail-row">
|
||||
<div class="label">Pass Type</div>
|
||||
<div class="value">${ticket.type === "member" ? "Member Pass" : "Public Pass"}</div>
|
||||
</div>
|
||||
|
||||
<div class="detail-row">
|
||||
<div class="label">Amount Paid</div>
|
||||
<div class="value">${formatPrice(ticket.price, ticket.currency)}</div>
|
||||
</div>
|
||||
|
||||
${
|
||||
paymentId
|
||||
? `
|
||||
<div class="detail-row">
|
||||
<div class="label">Transaction ID</div>
|
||||
<div class="value" style="font-family: monospace; font-size: 14px;">${paymentId}</div>
|
||||
</div>
|
||||
`
|
||||
: ""
|
||||
}
|
||||
|
||||
<div class="detail-row">
|
||||
<div class="label">Total Events</div>
|
||||
<div class="value">${events.length} events included</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="event-list">
|
||||
<h3 style="margin: 0 0 15px 0; color: #1a1a2e; font-size: 18px;">Your Event Schedule</h3>
|
||||
<p style="color: #666; font-size: 14px; margin-bottom: 15px;">
|
||||
You're automatically registered for all of these events:
|
||||
</p>
|
||||
|
||||
${events
|
||||
.map(
|
||||
(event, index) => `
|
||||
<div class="event-item">
|
||||
<div style="font-weight: 600; color: #7c3aed; margin-bottom: 5px;">
|
||||
Event ${index + 1}: ${event.title}
|
||||
</div>
|
||||
<div style="font-size: 14px; color: #666; margin: 5px 0;">
|
||||
📅 ${formatDate(event.startDate)}
|
||||
</div>
|
||||
<div style="font-size: 14px; color: #666; margin: 5px 0;">
|
||||
🕐 ${formatTime(event.startDate, event.endDate)}
|
||||
</div>
|
||||
<div style="font-size: 14px; color: #666; margin: 5px 0;">
|
||||
📍 ${event.location}
|
||||
</div>
|
||||
</div>
|
||||
`,
|
||||
)
|
||||
.join("")}
|
||||
</div>
|
||||
|
||||
<div style="text-align: center; margin: 30px 0;">
|
||||
<a href="https://ghostguild.org/dashboard" class="button">
|
||||
View in Dashboard
|
||||
</a>
|
||||
</div>
|
||||
|
||||
<div style="background-color: #fff; padding: 20px; border-radius: 8px; border: 1px solid #e5e7eb;">
|
||||
<h3 style="margin: 0 0 10px 0; font-size: 16px;">What's Next?</h3>
|
||||
<ul style="margin: 10px 0; padding-left: 20px;">
|
||||
<li>Mark these dates in your calendar</li>
|
||||
<li>You'll receive individual reminders before each event</li>
|
||||
<li>Event links and materials will be shared closer to each date</li>
|
||||
<li>Join the conversation in our Slack community</li>
|
||||
</ul>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="footer">
|
||||
<p style="margin: 10px 0;">
|
||||
Questions? Email us at
|
||||
<a href="mailto:events@babyghosts.org">events@babyghosts.org</a>
|
||||
</p>
|
||||
<p style="margin: 10px 0; color: #999; font-size: 12px;">
|
||||
Ghost Guild • Building solidarity economies in gaming
|
||||
</p>
|
||||
</div>
|
||||
</body>
|
||||
</html>
|
||||
`,
|
||||
});
|
||||
|
||||
if (error) {
|
||||
console.error("Failed to send series pass confirmation email:", error);
|
||||
return { success: false, error };
|
||||
}
|
||||
|
||||
return { success: true, data };
|
||||
} catch (error) {
|
||||
console.error("Error sending series pass confirmation email:", error);
|
||||
return { success: false, error };
|
||||
}
|
||||
}
|
||||
|
|
|
|||
750
server/utils/tickets.js
Normal file
750
server/utils/tickets.js
Normal file
|
|
@ -0,0 +1,750 @@
|
|||
// Ticket business logic utilities
|
||||
|
||||
/**
|
||||
* Calculate the applicable ticket price for a user
|
||||
* @param {Object} event - Event document
|
||||
* @param {Object} member - Member document (null if not a member)
|
||||
* @returns {Object} { ticketType, price, currency, isEarlyBird }
|
||||
*/
|
||||
export const calculateTicketPrice = (event, member = null) => {
|
||||
if (!event.tickets?.enabled) {
|
||||
// Legacy pricing model
|
||||
if (event.pricing?.paymentRequired && !event.pricing?.isFree) {
|
||||
return {
|
||||
ticketType: member ? "member" : "public",
|
||||
price: member ? 0 : event.pricing.publicPrice,
|
||||
currency: event.pricing.currency || "CAD",
|
||||
isEarlyBird: false,
|
||||
isFree: member ? true : event.pricing.publicPrice === 0,
|
||||
};
|
||||
}
|
||||
return {
|
||||
ticketType: "guest",
|
||||
price: 0,
|
||||
currency: "CAD",
|
||||
isEarlyBird: false,
|
||||
isFree: true,
|
||||
};
|
||||
}
|
||||
|
||||
const now = new Date();
|
||||
|
||||
// Member pricing
|
||||
if (member && event.tickets.member?.available) {
|
||||
const memberTicket = event.tickets.member;
|
||||
let price = memberTicket.price || 0;
|
||||
let isFree = memberTicket.isFree;
|
||||
|
||||
// Check for circle-specific overrides
|
||||
if (memberTicket.circleOverrides && member.circle) {
|
||||
const circleOverride = memberTicket.circleOverrides[member.circle];
|
||||
if (circleOverride) {
|
||||
if (circleOverride.isFree !== undefined) {
|
||||
isFree = circleOverride.isFree;
|
||||
}
|
||||
if (circleOverride.price !== undefined) {
|
||||
price = circleOverride.price;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
ticketType: "member",
|
||||
price: isFree ? 0 : price,
|
||||
currency: event.tickets.currency || "CAD",
|
||||
isEarlyBird: false,
|
||||
isFree,
|
||||
name: memberTicket.name || "Member Ticket",
|
||||
description: memberTicket.description,
|
||||
};
|
||||
}
|
||||
|
||||
// Public pricing
|
||||
if (event.tickets.public?.available) {
|
||||
const publicTicket = event.tickets.public;
|
||||
let price = publicTicket.price || 0;
|
||||
let isEarlyBird = false;
|
||||
|
||||
// Check for early bird pricing
|
||||
if (
|
||||
publicTicket.earlyBirdPrice !== undefined &&
|
||||
publicTicket.earlyBirdDeadline &&
|
||||
now < new Date(publicTicket.earlyBirdDeadline)
|
||||
) {
|
||||
price = publicTicket.earlyBirdPrice;
|
||||
isEarlyBird = true;
|
||||
}
|
||||
|
||||
return {
|
||||
ticketType: "public",
|
||||
price,
|
||||
currency: event.tickets.currency || "CAD",
|
||||
isEarlyBird,
|
||||
isFree: price === 0,
|
||||
name: publicTicket.name || "Public Ticket",
|
||||
description: publicTicket.description,
|
||||
};
|
||||
}
|
||||
|
||||
// No tickets available (members only event, user not a member)
|
||||
return null;
|
||||
};
|
||||
|
||||
/**
|
||||
* Check if tickets are available for an event
|
||||
* @param {Object} event - Event document
|
||||
* @param {String} ticketType - 'member' or 'public'
|
||||
* @returns {Object} { available, remaining, waitlistAvailable }
|
||||
*/
|
||||
export const checkTicketAvailability = (event, ticketType = "public") => {
|
||||
if (!event.tickets?.enabled) {
|
||||
// Legacy registration system
|
||||
if (!event.maxAttendees) {
|
||||
return { available: true, remaining: null, waitlistAvailable: false };
|
||||
}
|
||||
|
||||
const registered = event.registrations?.length || 0;
|
||||
const remaining = event.maxAttendees - registered;
|
||||
|
||||
return {
|
||||
available: remaining > 0,
|
||||
remaining: Math.max(0, remaining),
|
||||
waitlistAvailable: event.tickets?.waitlist?.enabled || false,
|
||||
};
|
||||
}
|
||||
|
||||
const registered = event.registrations?.length || 0;
|
||||
|
||||
// Check overall capacity first
|
||||
if (event.tickets.capacity?.total) {
|
||||
const totalRemaining = event.tickets.capacity.total - registered;
|
||||
if (totalRemaining <= 0) {
|
||||
return {
|
||||
available: false,
|
||||
remaining: 0,
|
||||
waitlistAvailable: event.tickets.waitlist?.enabled || false,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// Check ticket-type specific availability
|
||||
if (ticketType === "public" && event.tickets.public?.available) {
|
||||
if (event.tickets.public.quantity) {
|
||||
const sold = event.tickets.public.sold || 0;
|
||||
const reserved = event.tickets.public.reserved || 0;
|
||||
const remaining = event.tickets.public.quantity - sold - reserved;
|
||||
|
||||
return {
|
||||
available: remaining > 0,
|
||||
remaining: Math.max(0, remaining),
|
||||
waitlistAvailable: event.tickets.waitlist?.enabled || false,
|
||||
};
|
||||
}
|
||||
// Unlimited public tickets
|
||||
return { available: true, remaining: null, waitlistAvailable: false };
|
||||
}
|
||||
|
||||
if (ticketType === "member" && event.tickets.member?.available) {
|
||||
// Members typically have unlimited access unless capacity is reached
|
||||
if (event.tickets.capacity?.total) {
|
||||
const totalRemaining = event.tickets.capacity.total - registered;
|
||||
return {
|
||||
available: totalRemaining > 0,
|
||||
remaining: Math.max(0, totalRemaining),
|
||||
waitlistAvailable: event.tickets.waitlist?.enabled || false,
|
||||
};
|
||||
}
|
||||
// Unlimited member tickets
|
||||
return { available: true, remaining: null, waitlistAvailable: false };
|
||||
}
|
||||
|
||||
return { available: false, remaining: 0, waitlistAvailable: false };
|
||||
};
|
||||
|
||||
/**
|
||||
* Validate if a user can purchase a ticket
|
||||
* @param {Object} event - Event document
|
||||
* @param {Object} user - User data { email, name, member }
|
||||
* @returns {Object} { valid, reason, ticketInfo }
|
||||
*/
|
||||
export const validateTicketPurchase = (event, user) => {
|
||||
// Check if event is cancelled
|
||||
if (event.isCancelled) {
|
||||
return { valid: false, reason: "Event has been cancelled" };
|
||||
}
|
||||
|
||||
// Check if event has passed
|
||||
if (new Date(event.startDate) < new Date()) {
|
||||
return { valid: false, reason: "Event has already started" };
|
||||
}
|
||||
|
||||
// Check if registration deadline has passed
|
||||
if (
|
||||
event.registrationDeadline &&
|
||||
new Date(event.registrationDeadline) < new Date()
|
||||
) {
|
||||
return { valid: false, reason: "Registration deadline has passed" };
|
||||
}
|
||||
|
||||
// Check if user is already registered
|
||||
const alreadyRegistered = event.registrations?.some(
|
||||
(reg) =>
|
||||
reg.email.toLowerCase() === user.email.toLowerCase() && !reg.cancelledAt,
|
||||
);
|
||||
|
||||
if (alreadyRegistered) {
|
||||
return {
|
||||
valid: false,
|
||||
reason: "You are already registered for this event",
|
||||
};
|
||||
}
|
||||
|
||||
// Check member-only restrictions
|
||||
if (event.membersOnly && !user.member) {
|
||||
return {
|
||||
valid: false,
|
||||
reason: "This event is for members only. Please join to register.",
|
||||
};
|
||||
}
|
||||
|
||||
// Calculate ticket price and check availability
|
||||
const ticketInfo = calculateTicketPrice(event, user.member);
|
||||
|
||||
if (!ticketInfo) {
|
||||
return {
|
||||
valid: false,
|
||||
reason: "No tickets available for your membership status",
|
||||
};
|
||||
}
|
||||
|
||||
const availability = checkTicketAvailability(event, ticketInfo.ticketType);
|
||||
|
||||
if (!availability.available) {
|
||||
return {
|
||||
valid: false,
|
||||
reason: "Event is sold out",
|
||||
waitlistAvailable: availability.waitlistAvailable,
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
valid: true,
|
||||
ticketInfo,
|
||||
availability,
|
||||
};
|
||||
};
|
||||
|
||||
/**
|
||||
* Reserve a ticket temporarily during checkout (prevents race conditions)
|
||||
* @param {Object} event - Event document
|
||||
* @param {String} ticketType - 'member' or 'public'
|
||||
* @param {Number} ttl - Time to live in seconds (default 10 minutes)
|
||||
* @returns {Object} { success, reservationId, expiresAt }
|
||||
*/
|
||||
export const reserveTicket = async (event, ticketType, ttl = 600) => {
|
||||
const availability = checkTicketAvailability(event, ticketType);
|
||||
|
||||
if (!availability.available) {
|
||||
return {
|
||||
success: false,
|
||||
reason: "No tickets available",
|
||||
};
|
||||
}
|
||||
|
||||
// Increment reserved count
|
||||
if (ticketType === "public" && event.tickets.public) {
|
||||
event.tickets.public.reserved = (event.tickets.public.reserved || 0) + 1;
|
||||
}
|
||||
|
||||
if (event.tickets.capacity) {
|
||||
event.tickets.capacity.reserved =
|
||||
(event.tickets.capacity.reserved || 0) + 1;
|
||||
}
|
||||
|
||||
await event.save();
|
||||
|
||||
const expiresAt = new Date(Date.now() + ttl * 1000);
|
||||
|
||||
return {
|
||||
success: true,
|
||||
reservationId: `${event._id}-${ticketType}-${Date.now()}`,
|
||||
expiresAt,
|
||||
};
|
||||
};
|
||||
|
||||
/**
|
||||
* Release a reserved ticket (if payment fails or user abandons checkout)
|
||||
* @param {Object} event - Event document
|
||||
* @param {String} ticketType - 'member' or 'public'
|
||||
*/
|
||||
export const releaseTicket = async (event, ticketType) => {
|
||||
if (ticketType === "public" && event.tickets.public) {
|
||||
event.tickets.public.reserved = Math.max(
|
||||
0,
|
||||
(event.tickets.public.reserved || 0) - 1,
|
||||
);
|
||||
}
|
||||
|
||||
if (event.tickets.capacity) {
|
||||
event.tickets.capacity.reserved = Math.max(
|
||||
0,
|
||||
(event.tickets.capacity.reserved || 0) - 1,
|
||||
);
|
||||
}
|
||||
|
||||
await event.save();
|
||||
};
|
||||
|
||||
/**
|
||||
* Complete ticket purchase (after successful payment)
|
||||
* @param {Object} event - Event document
|
||||
* @param {String} ticketType - 'member' or 'public'
|
||||
*/
|
||||
export const completeTicketPurchase = async (event, ticketType) => {
|
||||
// Decrement reserved count
|
||||
await releaseTicket(event, ticketType);
|
||||
|
||||
// Increment sold count for public tickets
|
||||
if (ticketType === "public" && event.tickets.public) {
|
||||
event.tickets.public.sold = (event.tickets.public.sold || 0) + 1;
|
||||
}
|
||||
|
||||
await event.save();
|
||||
};
|
||||
|
||||
/**
|
||||
* Add user to waitlist
|
||||
* @param {Object} event - Event document
|
||||
* @param {Object} userData - { name, email, membershipLevel }
|
||||
* @returns {Object} { success, position }
|
||||
*/
|
||||
export const addToWaitlist = async (event, userData) => {
|
||||
if (!event.tickets?.waitlist?.enabled) {
|
||||
return { success: false, reason: "Waitlist is not enabled for this event" };
|
||||
}
|
||||
|
||||
// Check if already on waitlist
|
||||
const alreadyOnWaitlist = event.tickets.waitlist.entries?.some(
|
||||
(entry) => entry.email.toLowerCase() === userData.email.toLowerCase(),
|
||||
);
|
||||
|
||||
if (alreadyOnWaitlist) {
|
||||
return { success: false, reason: "You are already on the waitlist" };
|
||||
}
|
||||
|
||||
// Check waitlist capacity
|
||||
const maxSize = event.tickets.waitlist.maxSize;
|
||||
const currentSize = event.tickets.waitlist.entries?.length || 0;
|
||||
|
||||
if (maxSize && currentSize >= maxSize) {
|
||||
return { success: false, reason: "Waitlist is full" };
|
||||
}
|
||||
|
||||
// Add to waitlist
|
||||
if (!event.tickets.waitlist.entries) {
|
||||
event.tickets.waitlist.entries = [];
|
||||
}
|
||||
|
||||
event.tickets.waitlist.entries.push({
|
||||
name: userData.name,
|
||||
email: userData.email.toLowerCase(),
|
||||
membershipLevel: userData.membershipLevel || "non-member",
|
||||
addedAt: new Date(),
|
||||
notified: false,
|
||||
});
|
||||
|
||||
await event.save();
|
||||
|
||||
return {
|
||||
success: true,
|
||||
position: event.tickets.waitlist.entries.length,
|
||||
};
|
||||
};
|
||||
|
||||
/**
|
||||
* Format price for display
|
||||
* @param {Number} price - Price in cents or dollars
|
||||
* @param {String} currency - Currency code (default CAD)
|
||||
* @returns {String} Formatted price string
|
||||
*/
|
||||
export const formatPrice = (price, currency = "CAD") => {
|
||||
if (price === 0) return "Free";
|
||||
|
||||
return new Intl.NumberFormat("en-CA", {
|
||||
style: "currency",
|
||||
currency,
|
||||
}).format(price);
|
||||
};
|
||||
|
||||
// ============================================================================
|
||||
// SERIES TICKET FUNCTIONS
|
||||
// ============================================================================
|
||||
|
||||
/**
|
||||
* Calculate the applicable series pass price for a user
|
||||
* @param {Object} series - Series document
|
||||
* @param {Object} member - Member document (null if not a member)
|
||||
* @returns {Object} { ticketType, price, currency, isEarlyBird }
|
||||
*/
|
||||
export const calculateSeriesTicketPrice = (series, member = null) => {
|
||||
if (!series.tickets?.enabled) {
|
||||
return {
|
||||
ticketType: "guest",
|
||||
price: 0,
|
||||
currency: "CAD",
|
||||
isEarlyBird: false,
|
||||
isFree: true,
|
||||
};
|
||||
}
|
||||
|
||||
const now = new Date();
|
||||
|
||||
// Member pricing
|
||||
if (member && series.tickets.member?.available) {
|
||||
const memberTicket = series.tickets.member;
|
||||
let price = memberTicket.price || 0;
|
||||
let isFree = memberTicket.isFree;
|
||||
|
||||
// Check for circle-specific overrides
|
||||
if (memberTicket.circleOverrides && member.circle) {
|
||||
const circleOverride = memberTicket.circleOverrides[member.circle];
|
||||
if (circleOverride) {
|
||||
if (circleOverride.isFree !== undefined) {
|
||||
isFree = circleOverride.isFree;
|
||||
}
|
||||
if (circleOverride.price !== undefined) {
|
||||
price = circleOverride.price;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
ticketType: "member",
|
||||
price: isFree ? 0 : price,
|
||||
currency: series.tickets.currency || "CAD",
|
||||
isEarlyBird: false,
|
||||
isFree,
|
||||
name: memberTicket.name || "Member Series Pass",
|
||||
description: memberTicket.description,
|
||||
};
|
||||
}
|
||||
|
||||
// Public pricing
|
||||
if (series.tickets.public?.available) {
|
||||
const publicTicket = series.tickets.public;
|
||||
let price = publicTicket.price || 0;
|
||||
let isEarlyBird = false;
|
||||
|
||||
// Check for early bird pricing
|
||||
if (
|
||||
publicTicket.earlyBirdPrice !== undefined &&
|
||||
publicTicket.earlyBirdDeadline &&
|
||||
now < new Date(publicTicket.earlyBirdDeadline)
|
||||
) {
|
||||
price = publicTicket.earlyBirdPrice;
|
||||
isEarlyBird = true;
|
||||
}
|
||||
|
||||
return {
|
||||
ticketType: "public",
|
||||
price,
|
||||
currency: series.tickets.currency || "CAD",
|
||||
isEarlyBird,
|
||||
isFree: price === 0,
|
||||
name: publicTicket.name || "Series Pass",
|
||||
description: publicTicket.description,
|
||||
};
|
||||
}
|
||||
|
||||
// No tickets available
|
||||
return null;
|
||||
};
|
||||
|
||||
/**
|
||||
* Check if series passes are available
|
||||
* @param {Object} series - Series document
|
||||
* @param {String} ticketType - 'member' or 'public'
|
||||
* @returns {Object} { available, remaining, waitlistAvailable }
|
||||
*/
|
||||
export const checkSeriesTicketAvailability = (
|
||||
series,
|
||||
ticketType = "public",
|
||||
) => {
|
||||
if (!series.tickets?.enabled) {
|
||||
return { available: false, remaining: 0, waitlistAvailable: false };
|
||||
}
|
||||
|
||||
const registered =
|
||||
series.registrations?.filter((r) => !r.cancelledAt).length || 0;
|
||||
|
||||
// Check overall capacity first
|
||||
if (series.tickets.capacity?.total) {
|
||||
const totalRemaining = series.tickets.capacity.total - registered;
|
||||
if (totalRemaining <= 0) {
|
||||
return {
|
||||
available: false,
|
||||
remaining: 0,
|
||||
waitlistAvailable: series.tickets.waitlist?.enabled || false,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// Check ticket-type specific availability
|
||||
if (ticketType === "public" && series.tickets.public?.available) {
|
||||
if (series.tickets.public.quantity) {
|
||||
const sold = series.tickets.public.sold || 0;
|
||||
const reserved = series.tickets.public.reserved || 0;
|
||||
const remaining = series.tickets.public.quantity - sold - reserved;
|
||||
|
||||
return {
|
||||
available: remaining > 0,
|
||||
remaining: Math.max(0, remaining),
|
||||
waitlistAvailable: series.tickets.waitlist?.enabled || false,
|
||||
};
|
||||
}
|
||||
// Unlimited public tickets
|
||||
return { available: true, remaining: null, waitlistAvailable: false };
|
||||
}
|
||||
|
||||
if (ticketType === "member" && series.tickets.member?.available) {
|
||||
// Members typically have unlimited access unless capacity is reached
|
||||
if (series.tickets.capacity?.total) {
|
||||
const totalRemaining = series.tickets.capacity.total - registered;
|
||||
return {
|
||||
available: totalRemaining > 0,
|
||||
remaining: Math.max(0, totalRemaining),
|
||||
waitlistAvailable: series.tickets.waitlist?.enabled || false,
|
||||
};
|
||||
}
|
||||
// Unlimited member tickets
|
||||
return { available: true, remaining: null, waitlistAvailable: false };
|
||||
}
|
||||
|
||||
return { available: false, remaining: 0, waitlistAvailable: false };
|
||||
};
|
||||
|
||||
/**
|
||||
* Validate if a user can purchase a series pass
|
||||
* @param {Object} series - Series document
|
||||
* @param {Object} user - User data { email, name, member }
|
||||
* @returns {Object} { valid, reason, ticketInfo }
|
||||
*/
|
||||
export const validateSeriesTicketPurchase = (series, user) => {
|
||||
// Check if series is active
|
||||
if (!series.isActive) {
|
||||
return { valid: false, reason: "This series is not currently available" };
|
||||
}
|
||||
|
||||
// Check if user is already registered for the series
|
||||
const alreadyRegistered = series.registrations?.some(
|
||||
(reg) =>
|
||||
reg.email.toLowerCase() === user.email.toLowerCase() && !reg.cancelledAt,
|
||||
);
|
||||
|
||||
if (alreadyRegistered) {
|
||||
return { valid: false, reason: "You already have a pass for this series" };
|
||||
}
|
||||
|
||||
// Calculate ticket price and check availability
|
||||
const ticketInfo = calculateSeriesTicketPrice(series, user.member);
|
||||
|
||||
if (!ticketInfo) {
|
||||
return {
|
||||
valid: false,
|
||||
reason: "No series passes available for your membership status",
|
||||
};
|
||||
}
|
||||
|
||||
const availability = checkSeriesTicketAvailability(
|
||||
series,
|
||||
ticketInfo.ticketType,
|
||||
);
|
||||
|
||||
if (!availability.available) {
|
||||
return {
|
||||
valid: false,
|
||||
reason: "Series passes are sold out",
|
||||
waitlistAvailable: availability.waitlistAvailable,
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
valid: true,
|
||||
ticketInfo,
|
||||
availability,
|
||||
};
|
||||
};
|
||||
|
||||
/**
|
||||
* Reserve a series pass temporarily during checkout
|
||||
* @param {Object} series - Series document
|
||||
* @param {String} ticketType - 'member' or 'public'
|
||||
* @param {Number} ttl - Time to live in seconds (default 10 minutes)
|
||||
* @returns {Object} { success, reservationId, expiresAt }
|
||||
*/
|
||||
export const reserveSeriesTicket = async (series, ticketType, ttl = 600) => {
|
||||
const availability = checkSeriesTicketAvailability(series, ticketType);
|
||||
|
||||
if (!availability.available) {
|
||||
return {
|
||||
success: false,
|
||||
reason: "No series passes available",
|
||||
};
|
||||
}
|
||||
|
||||
// Increment reserved count
|
||||
if (ticketType === "public" && series.tickets.public) {
|
||||
series.tickets.public.reserved = (series.tickets.public.reserved || 0) + 1;
|
||||
}
|
||||
|
||||
if (series.tickets.capacity) {
|
||||
series.tickets.capacity.reserved =
|
||||
(series.tickets.capacity.reserved || 0) + 1;
|
||||
}
|
||||
|
||||
await series.save();
|
||||
|
||||
const expiresAt = new Date(Date.now() + ttl * 1000);
|
||||
|
||||
return {
|
||||
success: true,
|
||||
reservationId: `${series._id}-${ticketType}-${Date.now()}`,
|
||||
expiresAt,
|
||||
};
|
||||
};
|
||||
|
||||
/**
|
||||
* Release a reserved series pass
|
||||
* @param {Object} series - Series document
|
||||
* @param {String} ticketType - 'member' or 'public'
|
||||
*/
|
||||
export const releaseSeriesTicket = async (series, ticketType) => {
|
||||
if (ticketType === "public" && series.tickets.public) {
|
||||
series.tickets.public.reserved = Math.max(
|
||||
0,
|
||||
(series.tickets.public.reserved || 0) - 1,
|
||||
);
|
||||
}
|
||||
|
||||
if (series.tickets.capacity) {
|
||||
series.tickets.capacity.reserved = Math.max(
|
||||
0,
|
||||
(series.tickets.capacity.reserved || 0) - 1,
|
||||
);
|
||||
}
|
||||
|
||||
await series.save();
|
||||
};
|
||||
|
||||
/**
|
||||
* Complete series pass purchase (after successful payment)
|
||||
* @param {Object} series - Series document
|
||||
* @param {String} ticketType - 'member' or 'public'
|
||||
*/
|
||||
export const completeSeriesTicketPurchase = async (series, ticketType) => {
|
||||
// Decrement reserved count
|
||||
await releaseSeriesTicket(series, ticketType);
|
||||
|
||||
// Increment sold count for public tickets
|
||||
if (ticketType === "public" && series.tickets.public) {
|
||||
series.tickets.public.sold = (series.tickets.public.sold || 0) + 1;
|
||||
}
|
||||
|
||||
await series.save();
|
||||
};
|
||||
|
||||
/**
|
||||
* Check if a user has a valid series pass for a series
|
||||
* @param {Object} series - Series document
|
||||
* @param {String} userEmail - User email to check
|
||||
* @returns {Object} { hasPass, registration }
|
||||
*/
|
||||
export const checkUserSeriesPass = (series, userEmail) => {
|
||||
const registration = series.registrations?.find(
|
||||
(reg) =>
|
||||
reg.email.toLowerCase() === userEmail.toLowerCase() &&
|
||||
!reg.cancelledAt &&
|
||||
reg.paymentStatus !== "failed",
|
||||
);
|
||||
|
||||
return {
|
||||
hasPass: !!registration,
|
||||
registration: registration || null,
|
||||
};
|
||||
};
|
||||
|
||||
/**
|
||||
* Register user for all events in a series using their series pass
|
||||
* @param {Object} series - Series document
|
||||
* @param {Array} events - Array of event documents in the series
|
||||
* @param {Object} seriesRegistration - The series pass registration
|
||||
* @returns {Array} Array of event registration results
|
||||
*/
|
||||
export const registerForAllSeriesEvents = async (
|
||||
series,
|
||||
events,
|
||||
seriesRegistration,
|
||||
) => {
|
||||
const results = [];
|
||||
|
||||
for (const event of events) {
|
||||
try {
|
||||
// Check if already registered for this event
|
||||
const alreadyRegistered = event.registrations?.some(
|
||||
(reg) =>
|
||||
reg.email.toLowerCase() === seriesRegistration.email.toLowerCase() &&
|
||||
!reg.cancelledAt,
|
||||
);
|
||||
|
||||
if (alreadyRegistered) {
|
||||
results.push({
|
||||
eventId: event._id,
|
||||
success: false,
|
||||
reason: "Already registered",
|
||||
});
|
||||
continue;
|
||||
}
|
||||
|
||||
// Add registration to event
|
||||
event.registrations.push({
|
||||
memberId: seriesRegistration.memberId,
|
||||
name: seriesRegistration.name,
|
||||
email: seriesRegistration.email,
|
||||
membershipLevel: seriesRegistration.membershipLevel,
|
||||
isMember: seriesRegistration.isMember,
|
||||
ticketType: "series_pass",
|
||||
ticketPrice: 0, // Already paid at series level
|
||||
isSeriesTicketHolder: true,
|
||||
seriesTicketId: series._id,
|
||||
paymentStatus: "not_required", // Paid at series level
|
||||
registeredAt: new Date(),
|
||||
});
|
||||
|
||||
await event.save();
|
||||
|
||||
// Update series registration with event reference
|
||||
const eventReg = event.registrations[event.registrations.length - 1];
|
||||
seriesRegistration.eventRegistrations.push({
|
||||
eventId: event._id,
|
||||
registrationId: eventReg._id,
|
||||
});
|
||||
|
||||
results.push({
|
||||
eventId: event._id,
|
||||
success: true,
|
||||
registrationId: eventReg._id,
|
||||
});
|
||||
} catch (error) {
|
||||
results.push({
|
||||
eventId: event._id,
|
||||
success: false,
|
||||
reason: error.message,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Save series with updated event registrations
|
||||
await series.save();
|
||||
|
||||
return results;
|
||||
};
|
||||
Loading…
Add table
Add a link
Reference in a new issue