Add landing page

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