Consolidated and fixed routes

ufsasewebmaster · Feb 21, 2025 · 9c99246 · 9c99246
1 parent 63ab14d
commit 9c99246
Showing 1 changed file with 77 additions and 55 deletions.
diff --git a/src/server/api/events.ts b/src/server/api/events.ts
@@ -6,31 +6,20 @@ import { Hono } from "hono";
 
 const eventRoutes = new Hono();
 
-// Fetch all events
-eventRoutes.get("/events/all", async (c) => {
-  try {
-    const result = await db.select().from(Schema.events);
-    return c.json(result);
-  } catch {
-    return createErrorResponse(c, "MISSING_EVENT", "Cannot fetch events", 400);
-  }
-});
-
-// Fetch events between a start and end date (inclusive of partial overlaps)
+// Fetch events between a start and end date
 eventRoutes.get("/events", async (c) => {
   try {
-    // Collect startDate and endDate in UTC format
     const startDateStr = c.req.query("start_date");
     const endDateStr = c.req.query("end_date");
+
     if (!startDateStr || !endDateStr) {
-      return createErrorResponse(c, "", "Start and end dates are required", 400);
+      const result = await db.select().from(Schema.events);
+      return c.json(result);
     }
 
-    // Parse startDare and endDate into Date objects
     const startDate = new Date(startDateStr);
     const endDate = new Date(endDateStr);
 
-    // Validate the Date format
     if (isNaN(startDate.getTime()) || isNaN(endDate.getTime())) {
       return createErrorResponse(c, "DATE_FORMAT_INVALID", "Invalid date format", 400);
     }
@@ -41,79 +30,112 @@ eventRoutes.get("/events", async (c) => {
       .where(and(lte(Schema.events.start_time, endDate), gte(Schema.events.end_time, startDate)));
     return c.json(eventsData);
   } catch (error) {
-    if (error) return createErrorResponse(c, "FETCH_EVENTS_ERROR", error.toString(), 500);
+    if (error) return createErrorResponse(c, "MISSING_EVENT", error.toString(), 500);
   }
 });
 
-// Fetch event by ID
-eventRoutes.get("/events/:eventID", async (c) => {
+// Add event
+eventRoutes.post("/events", async (c) => {
   try {
-    const eventID = c.req.param("eventID");
-    if (!eventID) {
-      return createErrorResponse(c, "MISSING_EVENT_ID", "Event Id required", 400);
+    const body = await c.req.json();
+
+    const requiredFields = ["name", "location", "start_time", "end_time"];
+    for (const field of requiredFields) {
+      if (!body[field]) {
+        return createErrorResponse(c, "MISSING_REQUIRED_FIELD", `Field '${field}' is required`, 400);
+      }
     }
-    const result = await db.select().from(Schema.events).where(eq(Schema.events.id, eventID)).limit(1);
-    if (result.length === 0) {
-      return createErrorResponse(c, "EVENT_NOT_FOUND", "Event not found", 404);
+
+    const startTime = new Date(body.start_time);
+    const endTime = new Date(body.end_time);
+    if (isNaN(startTime.getTime()) || isNaN(endTime.getTime())) {
+      return createErrorResponse(c, "TIME_FORMAT_INVALID", "Invalid start_time or end_time format", 400);
     }
-    return c.json(result[0]);
-  } catch (error) {
-    if (error) return createErrorResponse(c, "FETCH_EVENT_ERROR", error.toString(), 500);
-  }
-});
 
-// Fetch event ID by name
-eventRoutes.get("/events/search/:name", async (c) => {
-  try {
-    const searchName = c.req.param("name");
     const result = await db
-      .select({ resEventIDs: Schema.events.id })
-      .from(Schema.events)
-      .where(like(Schema.events.name, `%${searchName}%`)); // Approximate search
-    const eventIDs = result.map((row) => row.resEventIDs);
-    return c.json(eventIDs);
-  } catch (error) {
-    if (error) return createErrorResponse(c, "SEARCH_EVENTS_ERROR", error.toString(), 500);
-  }
-});
-
-// Add event
-eventRoutes.post("/events/add", async (c) => {
-  try {
-    const eventData = await c.req.json();
-    const newEvent = await db
       .insert(Schema.events)
       .values({
-        ...eventData,
+        ...body,
+        start_time: startTime,
+        end_time: endTime,
       })
       .returning();
-    return c.json(`Inserted event with ID: ${newEvent[0].id}`);
+
+    return c.json({
+      message: `Inserted event with ID: ${result[0].id}`,
+      data: result[0],
+    });
   } catch (error) {
-    if (error) return createErrorResponse(c, "ADD_EVENT_ERROR", error.toString(), 500);
+    if (error) return createErrorResponse(c, "ADD_BLOG_ERROR", error.toString(), 500);
   }
 });
 
 // Update event
-eventRoutes.post("/events/update", async (c) => {
+eventRoutes.patch("/events", async (c) => {
   try {
     const body = await c.req.json();
     const { id, ...update } = body;
     if (!id) {
       return createErrorResponse(c, "MISSING_EVENT_ID", "Event ID required", 400);
     }
+    const existingEvent = await db.select().from(Schema.events).where(eq(Schema.events.id, id)).get();
+    if (!existingEvent) {
+      return createErrorResponse(c, "EVENT_NOT_FOUND", `No event with ID ${id}`, 404);
+    }
+    const startTime = new Date(body.start_time);
+    const endTime = new Date(body.end_time);
+    if (isNaN(startTime.getTime()) || isNaN(endTime.getTime())) {
+      return createErrorResponse(c, "TIME_FORMAT_INVALID", "Invalid start_time or end_time format", 400);
+    }
     const updatedEvent = await db
       .update(Schema.events)
       .set({
         ...update,
-        timeUpdated: new Date(),
-        lastUpdateDate: new Date(),
+        start_time: startTime,
+        end_time: endTime,
+        time_updated: new Date(),
       })
       .where(eq(Schema.events.id, id))
       .returning();
-    return c.json(`Updated event with ID: ${updatedEvent[0].id}`);
+    return c.json({
+      message: `Updated event with ID: ${updatedEvent[0].id}`,
+      data: updatedEvent[0],
+    });
   } catch (error) {
     if (error) return createErrorResponse(c, "UPDATE_EVENT_ERROR", error.toString(), 500);
   }
 });
 
+// Fetch event by ID
+eventRoutes.get("/events/:eventID", async (c) => {
+  try {
+    const eventID = c.req.param("eventID");
+    if (!eventID) {
+      return createErrorResponse(c, "MISSING_EVENT_ID", "Event Id required", 400);
+    }
+    const result = await db.select().from(Schema.events).where(eq(Schema.events.id, eventID)).limit(1);
+    if (result.length === 0) {
+      return createErrorResponse(c, "EVENT_NOT_FOUND", "Event not found", 404);
+    }
+    return c.json(result[0]);
+  } catch (error) {
+    if (error) return createErrorResponse(c, "FETCH_EVENT_ERROR", error.toString(), 500);
+  }
+});
+
+// Fetch event ID by name
+eventRoutes.get("/events/search/:name", async (c) => {
+  try {
+    const searchName = c.req.param("name");
+    const result = await db
+      .select({ resEventIDs: Schema.events.id })
+      .from(Schema.events)
+      .where(like(Schema.events.name, `%${searchName}%`)); // Approximate search
+    const eventIDs = result.map((row) => row.resEventIDs);
+    return c.json(eventIDs);
+  } catch (error) {
+    if (error) return createErrorResponse(c, "SEARCH_EVENTS_ERROR", error.toString(), 500);
+  }
+});
+
 export default eventRoutes;