Lots of UI fixes

server/api/admin/series.put.js

@@ -0,0 +1,62 @@
+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, title, description, type, totalEvents } = body
+
+    if (!id || !title) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: 'Series ID and title are required'
+      })
+    }
+
+    // Update the series record
+    const updatedSeries = await Series.findOneAndUpdate(
+      { id },
+      {
+        title,
+        description,
+        type,
+        totalEvents: totalEvents || null
+      },
+      { new: true }
+    )
+
+    if (!updatedSeries) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: 'Series not found'
+      })
+    }
+
+    // Update all events in this series with the new metadata
+    await Event.updateMany(
+      {
+        'series.id': id,
+        'series.isSeriesEvent': true
+      },
+      {
+        $set: {
+          'series.title': title,
+          'series.description': description,
+          'series.type': type,
+          'series.totalEvents': totalEvents || null
+        }
+      }
+    )
+
+    return updatedSeries
+  } catch (error) {
+    console.error('Error updating series:', error)
+    throw createError({
+      statusCode: 500,
+      statusMessage: 'Failed to update series'
+    })
+  }
+})

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

@@ -1,14 +1,15 @@
-import Event from '../../../models/event';
+import Event from "../../../models/event";
+import { sendEventCancellationEmail } from "../../../utils/resend.js";
 
 export default defineEventHandler(async (event) => {
-  const id = getRouterParam(event, 'id');
+  const id = getRouterParam(event, "id");
   const body = await readBody(event);
   const { email } = body;
 
   if (!email) {
     throw createError({
       statusCode: 400,
-      statusMessage: 'Email is required'
+      statusMessage: "Email is required",
     });
   }
 
@@ -24,22 +25,31 @@ export default defineEventHandler(async (event) => {
     if (!eventDoc) {
       throw createError({
         statusCode: 404,
-        statusMessage: 'Event not found'
+        statusMessage: "Event not found",
       });
     }
 
     // Find the registration index
     const registrationIndex = eventDoc.registrations.findIndex(
-      registration => registration.email.toLowerCase() === email.toLowerCase()
+      (registration) =>
+        registration.email.toLowerCase() === email.toLowerCase(),
     );
 
     if (registrationIndex === -1) {
       throw createError({
         statusCode: 404,
-        statusMessage: 'Registration not found'
+        statusMessage: "Registration not found",
       });
     }
 
+    // Store registration data before removing (convert to plain object)
+    const registration = {
+      name: eventDoc.registrations[registrationIndex].name,
+      email: eventDoc.registrations[registrationIndex].email,
+      membershipLevel:
+        eventDoc.registrations[registrationIndex].membershipLevel,
+    };
+
     // Remove the registration
     eventDoc.registrations.splice(registrationIndex, 1);
 
@@ -48,13 +58,26 @@ export default defineEventHandler(async (event) => {
 
     await eventDoc.save();
 
+    // Send cancellation confirmation email
+    try {
+      const eventData = {
+        title: eventDoc.title,
+        slug: eventDoc.slug,
+        _id: eventDoc._id,
+      };
+      await sendEventCancellationEmail(registration, eventData);
+    } catch (emailError) {
+      // Log error but don't fail the cancellation
+      console.error("Failed to send cancellation email:", emailError);
+    }
+
     return {
       success: true,
-      message: 'Registration cancelled successfully',
-      registeredCount: eventDoc.registeredCount
+      message: "Registration cancelled successfully",
+      registeredCount: eventDoc.registeredCount,
     };
   } catch (error) {
-    console.error('Error cancelling registration:', error);
+    console.error("Error cancelling registration:", error);
 
     // Re-throw known errors
     if (error.statusCode) {
@@ -63,7 +86,7 @@ export default defineEventHandler(async (event) => {
 
     throw createError({
       statusCode: 500,
-      statusMessage: 'Failed to cancel registration'
+      statusMessage: "Failed to cancel registration",
     });
   }
 });

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

@@ -1,6 +1,7 @@
 import Event from "../../../models/event.js";
 import Member from "../../../models/member.js";
 import { connectDB } from "../../../utils/mongoose.js";
+import { sendEventRegistrationEmail } from "../../../utils/resend.js";
 import mongoose from "mongoose";
 
 export default defineEventHandler(async (event) => {
@@ -102,7 +103,7 @@ export default defineEventHandler(async (event) => {
     }
 
     // Add registration
-    eventData.registrations.push({
+    const registration = {
       memberId: member ? member._id : null,
       name: body.name,
       email: body.email.toLowerCase(),
@@ -112,13 +113,20 @@ export default defineEventHandler(async (event) => {
       amountPaid: 0,
       dietary: body.dietary || false,
       registeredAt: new Date(),
-    });
+    };
+
+    eventData.registrations.push(registration);
 
     // Save the updated event
     await eventData.save();
 
-    // TODO: Send confirmation email using Resend
-    // await sendEventRegistrationEmail(body.email, eventData)
+    // Send confirmation email using Resend
+    try {
+      await sendEventRegistrationEmail(registration, eventData);
+    } catch (emailError) {
+      // Log error but don't fail the registration
+      console.error("Failed to send confirmation email:", emailError);
+    }
 
     return {
       success: true,

server/api/members/my-calendar.get.js

@@ -0,0 +1,114 @@
+import Event from "../../models/event";
+import Member from "../../models/member";
+
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event);
+  const { memberId } = query;
+
+  if (!memberId) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Member ID is required",
+    });
+  }
+
+  try {
+    // Verify member exists
+    const member = await Member.findById(memberId);
+    if (!member) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: "Member not found",
+      });
+    }
+
+    // Find all events where the user is registered
+    const events = await Event.find({
+      "registrations.memberId": memberId,
+      isCancelled: { $ne: true },
+    })
+      .select("title slug description startDate endDate location")
+      .sort({ startDate: 1 });
+
+    // Generate iCal format
+    const ical = generateICalendar(events, member);
+
+    // Set headers for calendar subscription (not download)
+    setHeader(event, "Content-Type", "text/calendar; charset=utf-8");
+    setHeader(event, "Cache-Control", "no-cache, no-store, must-revalidate");
+    setHeader(event, "Pragma", "no-cache");
+    setHeader(event, "Expires", "0");
+
+    return ical;
+  } catch (error) {
+    console.error("Error generating calendar:", error);
+
+    if (error.statusCode) {
+      throw error;
+    }
+
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Failed to generate calendar",
+    });
+  }
+});
+
+function generateICalendar(events, member) {
+  const now = new Date();
+  const timestamp = now
+    .toISOString()
+    .replace(/[-:]/g, "")
+    .replace(/\.\d{3}/, "");
+
+  let ical = [
+    "BEGIN:VCALENDAR",
+    "VERSION:2.0",
+    "PRODID:-//Ghost Guild//Events Calendar//EN",
+    "CALSCALE:GREGORIAN",
+    "METHOD:PUBLISH",
+    "X-WR-CALNAME:Ghost Guild - My Events",
+    "X-WR-TIMEZONE:UTC",
+    "X-WR-CALDESC:Your registered Ghost Guild events",
+    "REFRESH-INTERVAL;VALUE=DURATION:PT1H",
+    "X-PUBLISHED-TTL:PT1H",
+  ];
+
+  events.forEach((evt) => {
+    const eventStart = new Date(evt.startDate);
+    const eventEnd = new Date(evt.endDate);
+
+    const dtstart = eventStart
+      .toISOString()
+      .replace(/[-:]/g, "")
+      .replace(/\.\d{3}/, "");
+    const dtend = eventEnd
+      .toISOString()
+      .replace(/[-:]/g, "")
+      .replace(/\.\d{3}/, "");
+    const dtstamp = timestamp;
+
+    // Clean description for iCal format
+    const description = (evt.description || "")
+      .replace(/\n/g, "\\n")
+      .replace(/,/g, "\\,");
+
+    const eventUrl = `https://ghostguild.org/events/${evt.slug || evt._id}`;
+
+    ical.push("BEGIN:VEVENT");
+    ical.push(`UID:${evt._id}@ghostguild.org`);
+    ical.push(`DTSTAMP:${dtstamp}`);
+    ical.push(`DTSTART:${dtstart}`);
+    ical.push(`DTEND:${dtend}`);
+    ical.push(`SUMMARY:${evt.title}`);
+    ical.push(`DESCRIPTION:${description}\\n\\nView event: ${eventUrl}`);
+    ical.push(`LOCATION:${evt.location || "Online"}`);
+    ical.push(`URL:${eventUrl}`);
+    ical.push(`STATUS:CONFIRMED`);
+    ical.push("END:VEVENT");
+  });
+
+  ical.push("END:VCALENDAR");
+
+  return ical.join("\r\n");
+}