Adding features

server/api/events/[id]/cancel-registration.post.js

@@ -0,0 +1,69 @@
+import Event from '../../../models/event';
+
+export default defineEventHandler(async (event) => {
+  const id = getRouterParam(event, 'id');
+  const body = await readBody(event);
+  const { email } = body;
+
+  if (!email) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: 'Email is required'
+    });
+  }
+
+  try {
+    // Check if id is a valid ObjectId or treat as slug
+    const isObjectId = /^[0-9a-fA-F]{24}$/.test(id);
+    const query = isObjectId
+      ? { $or: [{ _id: id }, { slug: id }] }
+      : { slug: id };
+
+    const eventDoc = await Event.findOne(query);
+
+    if (!eventDoc) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: 'Event not found'
+      });
+    }
+
+    // Find the registration index
+    const registrationIndex = eventDoc.registrations.findIndex(
+      registration => registration.email.toLowerCase() === email.toLowerCase()
+    );
+
+    if (registrationIndex === -1) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: 'Registration not found'
+      });
+    }
+
+    // Remove the registration
+    eventDoc.registrations.splice(registrationIndex, 1);
+
+    // Update registered count
+    eventDoc.registeredCount = eventDoc.registrations.length;
+
+    await eventDoc.save();
+
+    return {
+      success: true,
+      message: 'Registration cancelled successfully',
+      registeredCount: eventDoc.registeredCount
+    };
+  } catch (error) {
+    console.error('Error cancelling registration:', error);
+
+    // Re-throw known errors
+    if (error.statusCode) {
+      throw error;
+    }
+
+    throw createError({
+      statusCode: 500,
+      statusMessage: 'Failed to cancel registration'
+    });
+  }
+});

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

@@ -0,0 +1,49 @@
+import Event from "../../../models/event";
+
+export default defineEventHandler(async (event) => {
+  const id = getRouterParam(event, "id");
+  const body = await readBody(event);
+  const { email } = body;
+
+  if (!email) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Email is required",
+    });
+  }
+
+  try {
+    // Check if id is a valid ObjectId or treat as slug
+    const isObjectId = /^[0-9a-fA-F]{24}$/.test(id);
+    const query = isObjectId
+      ? { $or: [{ _id: id }, { slug: id }] }
+      : { slug: id };
+
+    const eventDoc = await Event.findOne(query);
+
+    if (!eventDoc) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: "Event not found",
+      });
+    }
+
+    // Check if the email exists in the registrations array
+    const isRegistered = eventDoc.registrations.some(
+      (registration) =>
+        registration.email.toLowerCase() === email.toLowerCase(),
+    );
+
+    return {
+      isRegistered,
+      eventId: eventDoc._id,
+      eventTitle: eventDoc.title,
+    };
+  } catch (error) {
+    console.error("Error checking registration:", error);
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Failed to check registration status",
+    });
+  }
+});

server/api/events/[id]/register.post.js

@@ -1,130 +1,141 @@
-import Event from '../../../models/event.js'
-import Member from '../../../models/member.js'
-import { connectDB } from '../../../utils/mongoose.js'
-import mongoose from 'mongoose'
+import Event from "../../../models/event.js";
+import Member from "../../../models/member.js";
+import { connectDB } from "../../../utils/mongoose.js";
+import mongoose from "mongoose";
 
 export default defineEventHandler(async (event) => {
   try {
     // Ensure database connection
-    await connectDB()
-    const identifier = getRouterParam(event, 'id')
-    const body = await readBody(event)
-    
+    await connectDB();
+    const identifier = getRouterParam(event, "id");
+    const body = await readBody(event);
+
     if (!identifier) {
       throw createError({
         statusCode: 400,
-        statusMessage: 'Event identifier is required'
-      })
+        statusMessage: "Event identifier is required",
+      });
     }
-    
+
     // Validate required fields
     if (!body.name || !body.email) {
       throw createError({
         statusCode: 400,
-        statusMessage: 'Name and email are required'
-      })
+        statusMessage: "Name and email are required",
+      });
     }
-    
+
     // Fetch the event - try by slug first, then by ID
-    let eventData
-    
+    let eventData;
+
     // Check if identifier is a valid MongoDB ObjectId
     if (mongoose.Types.ObjectId.isValid(identifier)) {
-      eventData = await Event.findById(identifier)
+      eventData = await Event.findById(identifier);
     }
-    
+
     // If not found by ID or not a valid ObjectId, try by slug
     if (!eventData) {
-      eventData = await Event.findOne({ slug: identifier })
+      eventData = await Event.findOne({ slug: identifier });
     }
-    
+
     if (!eventData) {
       throw createError({
         statusCode: 404,
-        statusMessage: 'Event not found'
-      })
+        statusMessage: "Event not found",
+      });
     }
-    
+
     // Check if event is full
-    if (eventData.maxAttendees && eventData.registrations.length >= eventData.maxAttendees) {
+    if (
+      eventData.maxAttendees &&
+      eventData.registrations.length >= eventData.maxAttendees
+    ) {
       throw createError({
         statusCode: 400,
-        statusMessage: 'Event is full'
-      })
+        statusMessage: "Event is full",
+      });
     }
-    
+
     // Check if already registered
     const alreadyRegistered = eventData.registrations.some(
-      reg => reg.email.toLowerCase() === body.email.toLowerCase()
-    )
-    
+      (reg) => reg.email.toLowerCase() === body.email.toLowerCase(),
+    );
+
     if (alreadyRegistered) {
       throw createError({
         statusCode: 400,
-        statusMessage: 'You are already registered for this event'
-      })
+        statusMessage: "You are already registered for this event",
+      });
     }
-    
+
     // Check member status and handle different registration scenarios
-    const member = await Member.findOne({ email: body.email.toLowerCase() })
-    
+    const member = await Member.findOne({ email: body.email.toLowerCase() });
+
     if (eventData.membersOnly && !member) {
       throw createError({
         statusCode: 403,
-        statusMessage: 'This event is for members only. Please become a member to register.'
-      })
+        statusMessage:
+          "This event is for members only. Please become a member to register.",
+      });
     }
-    
+
     // If event requires payment and user is not a member, redirect to payment flow
-    if (eventData.pricing.paymentRequired && !eventData.pricing.isFree && !member) {
+    if (
+      eventData.pricing.paymentRequired &&
+      !eventData.pricing.isFree &&
+      !member
+    ) {
       throw createError({
         statusCode: 402, // Payment Required
-        statusMessage: 'This event requires payment. Please use the payment registration endpoint.'
-      })
+        statusMessage:
+          "This event requires payment. Please use the payment registration endpoint.",
+      });
     }
-    
+
     // Set member status and membership level
-    let isMember = false
-    let membershipLevel = 'non-member'
-    
+    let isMember = false;
+    let membershipLevel = "non-member";
+
     if (member) {
-      isMember = true
-      membershipLevel = `${member.circle}-${member.contributionTier}`
+      isMember = true;
+      membershipLevel = `${member.circle}-${member.contributionTier}`;
     }
-    
+
     // Add registration
     eventData.registrations.push({
+      memberId: member ? member._id : null,
       name: body.name,
       email: body.email.toLowerCase(),
       membershipLevel,
       isMember,
-      paymentStatus: 'not_required', // Free events or member registrations
+      paymentStatus: "not_required", // Free events or member registrations
       amountPaid: 0,
       dietary: body.dietary || false,
-      registeredAt: new Date()
-    })
-    
+      registeredAt: new Date(),
+    });
+
     // Save the updated event
-    await eventData.save()
-    
+    await eventData.save();
+
     // TODO: Send confirmation email using Resend
     // await sendEventRegistrationEmail(body.email, eventData)
-    
+
     return {
       success: true,
-      message: 'Successfully registered for the event',
-      registrationId: eventData.registrations[eventData.registrations.length - 1]._id
-    }
+      message: "Successfully registered for the event",
+      registrationId:
+        eventData.registrations[eventData.registrations.length - 1]._id,
+    };
   } catch (error) {
-    console.error('Error registering for event:', error)
-    
+    console.error("Error registering for event:", error);
+
     if (error.statusCode) {
-      throw error
+      throw error;
     }
-    
+
     throw createError({
       statusCode: 500,
-      statusMessage: 'Failed to register for event'
-    })
+      statusMessage: "Failed to register for event",
+    });
   }
-})
+});