Add landing page

server/api/admin/series.get.js

@@ -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",
+    });
   }
-})
+});

server/api/admin/series/tickets.put.js

@@ -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'
+    })
+  }
+})

server/api/events/[id]/check-series-access.get.js

@@ -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",
+    });
+  }
+});

server/api/events/[id]/tickets/available.get.js

@@ -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",
+    });
+  }
+});

server/api/events/[id]/tickets/check-eligibility.post.js

@@ -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",
+    });
+  }
+});

server/api/events/[id]/tickets/purchase.post.js

@@ -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.",
+    });
+  }
+});

server/api/events/[id]/tickets/reserve.post.js

@@ -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",
+    });
+  }
+});

server/api/helcim/initialize-payment.post.js

@@ -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",
+    });
   }
-})
+});

server/api/series/[id].get.js

@@ -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",
+    });
   }
-})
+});

server/api/series/[id]/tickets/available.get.js

@@ -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",
+    });
+  }
+});

server/api/series/[id]/tickets/check-eligibility.post.js

@@ -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",
+    });
+  }
+});

server/api/series/[id]/tickets/purchase.post.js

@@ -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",
+    });
+  }
+});