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