Add landing page

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