feat:#65 updated backend deps

services/data-manager/service/addRoute.go

@@ -27,442 +27,261 @@ import (
 	"log/slog"
 	"net/http"
 
-	"github.com/labstack/echo/v5"
 	"github.com/pocketbase/pocketbase/apis"
 	"github.com/pocketbase/pocketbase/core"
 )
 
 func AddRoutes(services serviceModel.Service) {
 
-	services.App.OnBeforeServe().Add(func(e *core.ServeEvent) error {
-		_, err := e.Router.AddRoute(echo.Route{
-			Method: http.MethodGet,
-			Path:   "/api/fetch/events",
-			Handler: func(c echo.Context) error {
-				savedEvents, err := v2.ParseEventsFromRemote(services.App)
+	services.App.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		se.Router.GET("/api/fetch/events", func(e *core.RequestEvent) error {
+			savedEvents, err := v2.ParseEventsFromRemote(services.App)
+			if err != nil {
+				slog.Error("Failed to parse events from remote: ", "error", err)
+				return e.JSON(http.StatusBadRequest, "Failed to parse events from remote")
+			} else {
+				return e.JSON(http.StatusOK, savedEvents)
+			}
+		}).Bind(apis.RequireSuperuserAuth())
+		return se.Next()
+	})
+
+	services.App.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		se.Router.GET("/api/fetch/daily/events", func(e *core.RequestEvent) error {
+			clock := time.RealClock{}
+			course.UpdateCourse(services, clock)
+			return e.JSON(http.StatusOK, "Daily events fetched")
+		}).Bind(apis.RequireSuperuserAuth())
+		return se.Next()
+	})
+
+	services.App.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		se.Router.GET("/api/fetch/group", func(e *core.RequestEvent) error {
+			seminarGroupString := e.Request.PathValue("seminarGroup")
+
+			if seminarGroupString == "" {
+				return e.JSON(http.StatusBadRequest, "Seminar group could not be empty")
+			} else {
+				//find seminar group by name
+				seminarGroup, err := services.CourseService.FindCourseByCourseName(seminarGroupString)
 				if err != nil {
-					slog.Error("Failed to parse events from remote: ", "error", err)
-					return c.JSON(http.StatusBadRequest, "Failed to parse events from remote")
-				} else {
-					return c.JSON(http.StatusOK, savedEvents)
-				}
-			},
-			Middlewares: []echo.MiddlewareFunc{
-				apis.ActivityLogger(services.App),
-				apis.RequireAdminAuth(),
-			},
-		})
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-
-	services.App.OnBeforeServe().Add(func(e *core.ServeEvent) error {
-		_, err := e.Router.AddRoute(echo.Route{
-			Method: http.MethodGet,
-			Path:   "/api/fetch/daily/events",
-			Handler: func(c echo.Context) error {
-				clock := time.RealClock{}
-				course.UpdateCourse(services, clock)
-				return c.JSON(http.StatusOK, "Daily events fetched")
-			},
-			Middlewares: []echo.MiddlewareFunc{
-				apis.ActivityLogger(services.App),
-				apis.RequireAdminAuth(),
-			},
-		})
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-
-	services.App.OnBeforeServe().Add(func(e *core.ServeEvent) error {
-		_, err := e.Router.AddRoute(echo.Route{
-			Method: http.MethodGet,
-			Path:   "/api/fetch/group",
-			Handler: func(c echo.Context) error {
-
-				seminarGroupString := c.QueryParam("seminarGroup")
-
-				if seminarGroupString == "" {
-					return c.JSON(http.StatusBadRequest, "Seminar group could not be empty")
-				} else {
-					//find seminar group by name
-					seminarGroup, err := services.CourseService.FindCourseByCourseName(seminarGroupString)
-					if err != nil {
-						return c.JSON(http.StatusBadRequest, "Failed to find seminar group")
-					}
-
-					events, err := services.EventService.UpdateModulesForCourse(seminarGroup)
-					if err != nil {
-						return c.JSON(http.StatusBadRequest, "Failed to fetch seminar group")
-					}
-					return c.JSON(http.StatusOK, events)
+					return e.JSON(http.StatusBadRequest, "Failed to find seminar group")
 				}
 
-			},
-			Middlewares: []echo.MiddlewareFunc{
-				apis.ActivityLogger(services.App),
-				apis.RequireAdminAuth(),
-			},
-		})
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-
-	services.App.OnBeforeServe().Add(func(e *core.ServeEvent) error {
-		_, err := e.Router.AddRoute(echo.Route{
-			Method: http.MethodGet,
-			Path:   "/api/fetch/groups",
-			Handler: func(c echo.Context) error {
-				groups, err := v1.FetchSeminarGroups(services.App)
+				events, err := services.EventService.UpdateModulesForCourse(seminarGroup)
 				if err != nil {
-					return c.JSON(http.StatusBadRequest, "Failed to fetch seminar groups")
+					return e.JSON(http.StatusBadRequest, "Failed to fetch seminar group")
 				}
-				return c.JSON(http.StatusOK, groups)
-			},
-			Middlewares: []echo.MiddlewareFunc{
-				apis.ActivityLogger(services.App),
-				apis.RequireAdminAuth(),
-			},
-		})
-		if err != nil {
-			return err
-		}
-		return nil
+				return e.JSON(http.StatusOK, events)
+			}
+
+		}).Bind(apis.RequireSuperuserAuth())
+		return se.Next()
 	})
 
-	services.App.OnBeforeServe().Add(func(e *core.ServeEvent) error {
-		_, err := e.Router.AddRoute(echo.Route{
-			Method: http.MethodGet,
-			Path:   "/api/fetch/sports",
-			Handler: func(c echo.Context) error {
-
-				sportEvents, err := sport.FetchAndUpdateSportEvents(services.App)
-				if err != nil {
-					return c.JSON(http.StatusBadRequest, "Failed to fetch sport events")
-				}
-				return c.JSON(http.StatusOK, sportEvents)
-			},
-			Middlewares: []echo.MiddlewareFunc{
-				apis.ActivityLogger(services.App),
-				apis.RequireAdminAuth(),
-			},
-		})
-		if err != nil {
-			return err
-		}
-		return nil
+	services.App.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		se.Router.GET("/api/fetch/groups", func(e *core.RequestEvent) error {
+			groups, err := v1.FetchSeminarGroups(services.App)
+			if err != nil {
+				slog.Error("Failed to fetch seminar groups: ", "error", err)
+				return e.JSON(http.StatusBadRequest, "Failed to fetch seminar groups")
+			} else {
+				return e.JSON(http.StatusOK, groups)
+			}
+		}).Bind(apis.RequireSuperuserAuth())
+		return se.Next()
 	})
 
-	services.App.OnBeforeServe().Add(func(e *core.ServeEvent) error {
-		_, err := e.Router.AddRoute(echo.Route{
-			Method: http.MethodDelete,
-			Path:   "/api/modules",
-			Handler: func(c echo.Context) error {
-				err := services.EventService.DeleteAllEvents()
-				if err != nil {
-					return c.JSON(http.StatusBadRequest, "Failed to delete events")
-				}
-				return c.JSON(http.StatusOK, "Events deleted")
-			},
-			Middlewares: []echo.MiddlewareFunc{
-				apis.ActivityLogger(services.App),
-				apis.RequireAdminAuth(),
-			},
-		})
-		if err != nil {
-			return err
-		}
-		return nil
+	services.App.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		se.Router.GET("/api/fetch/sports", func(e *core.RequestEvent) error {
+			sportEvents, err := sport.FetchAndUpdateSportEvents(services.App)
+			if err != nil {
+				slog.Error("Failed to fetch sport events: ", "error", err)
+				return e.JSON(http.StatusBadRequest, "Failed to fetch sport events")
+			} else {
+				return e.JSON(http.StatusOK, sportEvents)
+			}
+		}).Bind(apis.RequireSuperuserAuth())
+		return se.Next()
 	})
 
-	services.App.OnBeforeServe().Add(func(e *core.ServeEvent) error {
-		_, err := e.Router.AddRoute(echo.Route{
-			Method: http.MethodGet,
-			Path:   "/api/rooms",
-			Handler: func(c echo.Context) error {
-				rooms, err := room.GetRooms(services.App)
-				if err != nil {
-					return c.JSON(http.StatusBadRequest, "Failed to get rooms")
-				}
-				return c.JSON(http.StatusOK, rooms)
-			},
-			Middlewares: []echo.MiddlewareFunc{
-				apis.ActivityLogger(services.App),
-			},
-		})
-		if err != nil {
-			return err
-		}
-		return nil
+	services.App.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		se.Router.DELETE("/api/modules", func(e *core.RequestEvent) error {
+			err := services.EventService.DeleteAllEvents()
+			if err != nil {
+				return e.JSON(http.StatusBadRequest, "Failed to delete events")
+			}
+			return e.JSON(http.StatusOK, "Events deleted")
+		}).Bind(apis.RequireSuperuserAuth())
+		return se.Next()
 	})
 
-	// API Endpoint to get all events for a specific room on a specific day
-	services.App.OnBeforeServe().Add(func(e *core.ServeEvent) error {
-		_, err := e.Router.AddRoute(echo.Route{
-			Method: http.MethodGet,
-			Path:   "/api/schedule/day",
-			Handler: func(c echo.Context) error {
-				roomParam := c.QueryParam("room")
-				date := c.QueryParam("date")
-				roomSchedule, err := room.GetRoomScheduleForDay(services.App, roomParam, date)
-				if err != nil {
-					slog.Error("Failed to get room schedule for day: ", "error", err)
-					return c.JSON(http.StatusBadRequest, "Failed to get room schedule for day")
-				}
-				return c.JSON(http.StatusOK, roomSchedule)
-			},
-			Middlewares: []echo.MiddlewareFunc{
-				apis.ActivityLogger(services.App),
-			},
+	services.App.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		se.Router.GET("/api/rooms", func(e *core.RequestEvent) error {
+			rooms, err := room.GetRooms(services.App)
+			if err != nil {
+				return e.JSON(http.StatusBadRequest, "Failed to get rooms")
+			}
+			return e.JSON(http.StatusOK, rooms)
 		})
-		if err != nil {
-			return err
-		}
-		return nil
+		return se.Next()
+	})
+
+	services.App.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		se.Router.GET("/api/schedule/day", func(e *core.RequestEvent) error {
+			roomParam := e.Request.PathValue("room")
+			date := e.Request.PathValue("date")
+			roomSchedule, err := room.GetRoomScheduleForDay(services.App, roomParam, date)
+			if err != nil {
+				slog.Error("Failed to get room schedule for day: ", "error", err)
+				return e.JSON(http.StatusBadRequest, "Failed to get room schedule for day")
+			}
+			return e.JSON(http.StatusOK, roomSchedule)
+		})
+		return se.Next()
 	})
 
 	// API Endpoint to create a new iCal feed
-	services.App.OnBeforeServe().Add(func(e *core.ServeEvent) error {
-		_, err := e.Router.AddRoute(echo.Route{
-			Method: http.MethodGet,
-			Path:   "/api/schedule",
-			Handler: func(c echo.Context) error {
-				roomParam := c.QueryParam("room")
-				to := c.QueryParam("to")
-				from := c.QueryParam("from")
-				mapped := c.QueryParam("mapped")
-				roomSchedule, err := room.GetRoomSchedule(services.App, roomParam, from, to, mapped)
-				if err != nil {
-					slog.Error("Failed to get room schedule:", "error", err)
-					return c.JSON(http.StatusBadRequest, "Failed to get room schedule")
-				}
-				return c.JSON(http.StatusOK, roomSchedule)
-			},
-			Middlewares: []echo.MiddlewareFunc{
-				apis.ActivityLogger(services.App),
-			},
+	services.App.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		se.Router.GET("/api/schedule", func(e *core.RequestEvent) error {
+			roomParam := e.Request.PathValue("room")
+			to := e.Request.PathValue("to")
+			from := e.Request.PathValue("from")
+			mapped := e.Request.PathValue("mapped")
+			roomSchedule, err := room.GetRoomSchedule(services.App, roomParam, from, to, mapped)
+			if err != nil {
+				slog.Error("Failed to get room schedule: ", "error", err)
+				return e.JSON(http.StatusBadRequest, "Failed to get room schedule")
+			}
+			return e.JSON(http.StatusOK, roomSchedule)
 		})
-		if err != nil {
-			return err
-		}
-		return nil
+		return se.Next()
 	})
 
 	// API Endpoint to get all rooms that have no events in a specific time frame
-	services.App.OnBeforeServe().Add(func(e *core.ServeEvent) error {
-		_, err := e.Router.AddRoute(echo.Route{
-			Method: http.MethodGet,
-			Path:   "/api/rooms/free",
-			Handler: func(c echo.Context) error {
-				from, err := time.ParseTime(c.QueryParam("from"))
-				if err != nil {
-					slog.Error("Failed to parse time: ", "error", err)
-					return c.JSON(http.StatusBadRequest, "Failed to parse time")
-				}
-				to, err := time.ParseTime(c.QueryParam("to"))
-				if err != nil {
-					slog.Error("Failed to parse time: ", "error", err)
-					return c.JSON(http.StatusBadRequest, "Failed to parse time")
-				}
-				rooms, err := room.GetFreeRooms(services.App, from, to)
-				if err != nil {
-					slog.Error("Failed to get free rooms: ", "error", err)
-					return c.JSON(http.StatusBadRequest, "Failed to get free rooms")
-				}
-				return c.JSON(http.StatusOK, rooms)
-			},
-			Middlewares: []echo.MiddlewareFunc{
-				apis.ActivityLogger(services.App),
-			},
+	services.App.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		se.Router.GET("/api/rooms/free", func(e *core.RequestEvent) error {
+			from, err := time.ParseTime(e.Request.PathValue("from"))
+			if err != nil {
+				slog.Error("Failed to parse time: ", "error", err)
+				return e.JSON(http.StatusBadRequest, "Failed to parse time")
+			}
+			to, err := time.ParseTime(e.Request.PathValue("to"))
+			if err != nil {
+				slog.Error("Failed to parse time: ", "error", err)
+				return e.JSON(http.StatusBadRequest, "Failed to parse time")
+			}
+			rooms, err := room.GetFreeRooms(services.App, from, to)
+			if err != nil {
+				slog.Error("Failed to get free rooms: ", "error", err)
+				return e.JSON(http.StatusBadRequest, "Failed to get free rooms")
+			}
+			return e.JSON(http.StatusOK, rooms)
 		})
-		if err != nil {
-			return err
-		}
-		return nil
+		return se.Next()
 	})
 
 	addFeedRoutes(services.App)
 
-	services.App.OnBeforeServe().Add(func(e *core.ServeEvent) error {
-		_, err := e.Router.AddRoute(echo.Route{
-			Method: http.MethodGet,
-			Path:   "/api/course/modules",
-			Handler: func(c echo.Context) error {
-				modules, err := services.EventService.GetModulesForCourseDistinct(
-					c.QueryParam("course"),
-					c.QueryParam("semester"),
-				)
-
-				if err != nil {
-					slog.Error("Failed to get modules for course and semester: ", "error", err)
-					return c.JSON(http.StatusBadRequest, "Failed to get modules for course and semester")
-				} else {
-					return c.JSON(http.StatusOK, modules)
-				}
-			},
-			Middlewares: []echo.MiddlewareFunc{
-				apis.ActivityLogger(services.App),
-			},
+	services.App.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		se.Router.GET("/api/course/modules", func(e *core.RequestEvent) error {
+			modules, err := services.EventService.GetModulesForCourseDistinct(
+				e.Request.PathValue("course"),
+				e.Request.PathValue("semester"),
+			)
+			if err != nil {
+				slog.Error("Failed to get modules for course and semester: ", "error", err)
+				return e.JSON(http.StatusBadRequest, "Failed to get modules for course and semester")
+			}
+			return e.JSON(http.StatusOK, modules)
 		})
-		if err != nil {
-			return err
-		}
-		return nil
+		return se.Next()
 	})
 
-	services.App.OnBeforeServe().Add(func(e *core.ServeEvent) error {
-		_, err := e.Router.AddRoute(echo.Route{
-			Method: http.MethodGet,
-			Path:   "/api/modules",
-			Handler: func(c echo.Context) error {
-				modules, err := services.EventService.GetAllModulesDistinct()
-				if err != nil {
-					slog.Error("Failed to get modules: ", "error", err)
-					return c.JSON(http.StatusBadRequest, "Failed to get modules")
-				}
-				return c.JSON(http.StatusOK, modules)
-			},
-			Middlewares: []echo.MiddlewareFunc{
-				apis.ActivityLogger(services.App),
-			},
+	services.App.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		se.Router.GET("/api/modules", func(e *core.RequestEvent) error {
+			modules, err := services.EventService.GetAllModulesDistinct()
+			if err != nil {
+				slog.Error("Failed to get modules: ", "error", err)
+				return e.JSON(http.StatusBadRequest, "Failed to get modules")
+			}
+			return e.JSON(http.StatusOK, modules)
 		})
-		if err != nil {
-			return err
-		}
-		return nil
+		return se.Next()
 	})
 
-	services.App.OnBeforeServe().Add(func(e *core.ServeEvent) error {
-		_, err := e.Router.AddRoute(echo.Route{
-			Method: http.MethodGet,
-			Path:   "/api/module",
-			Handler: func(c echo.Context) error {
-				requestModule := c.QueryParam("uuid")
-				module, err := services.EventService.GetModuleByUUID(requestModule)
-				if err != nil {
-					slog.Error("Failed to get module: ", "error", err)
-					return c.JSON(http.StatusBadRequest, "Failed to get module")
-				} else {
-					return c.JSON(http.StatusOK, module)
-				}
-			},
-			Middlewares: []echo.MiddlewareFunc{
-				apis.ActivityLogger(services.App),
-			},
+	services.App.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		se.Router.GET("/api/module", func(e *core.RequestEvent) error {
+			requestModule := e.Request.PathValue("uuid")
+			module, err := services.EventService.GetModuleByUUID(requestModule)
+			if err != nil {
+				slog.Error("Failed to get module: ", "error", err)
+				return e.JSON(http.StatusBadRequest, "Failed to get module")
+			}
+			return e.JSON(http.StatusOK, module)
 		})
-		if err != nil {
-			return err
-		}
-		return nil
+		return se.Next()
 	})
 
-	services.App.OnBeforeServe().Add(func(e *core.ServeEvent) error {
-		_, err := e.Router.AddRoute(echo.Route{
-			Method: http.MethodGet,
-			Path:   "/api/courses",
-			Handler: func(c echo.Context) error {
-				semester := c.QueryParam("semester")
-				if semester == "" {
-					courses := services.CourseService.GetAllCourses()
-					return c.JSON(200, courses)
-				} else {
-					seminarGroups := services.CourseService.GetAllCoursesForSemester(semester)
-					courseStringList := make([]string, 0)
-					for _, seminarGroup := range seminarGroups {
-						courseStringList = append(courseStringList, seminarGroup.Course)
-					}
-					return c.JSON(200, courseStringList)
+	services.App.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		se.Router.GET("/api/courses", func(e *core.RequestEvent) error {
+			semester := e.Request.PathValue("semester")
+			if semester == "" {
+				courses := services.CourseService.GetAllCourses()
+				return e.JSON(200, courses)
+			} else {
+				seminarGroups := services.CourseService.GetAllCoursesForSemester(semester)
+				courseStringList := make([]string, 0)
+				for _, seminarGroup := range seminarGroups {
+					courseStringList = append(courseStringList, seminarGroup.Course)
 				}
-			},
-			Middlewares: []echo.MiddlewareFunc{
-				apis.ActivityLogger(services.App),
-			},
+				return e.JSON(200, courseStringList)
+			}
 		})
-		if err != nil {
-			return err
-		}
-		return nil
+		return se.Next()
 	})
 
-	// api end point to get all courses for a specific semester with courses that have events
-	services.App.OnBeforeServe().Add(func(e *core.ServeEvent) error {
-		_, err := e.Router.AddRoute(echo.Route{
-			Method: http.MethodGet,
-			Path:   "/api/courses/events",
-			Handler: func(c echo.Context) error {
-				semester := c.QueryParam("semester")
-				courses, err := services.CourseService.GetAllCoursesForSemesterWithEvents(semester)
-				if err != nil {
-					slog.Error("Failed to get courses for semester with events: ", "error", err)
-					return c.JSON(http.StatusBadRequest, "Failed to get courses for semester with events")
-				} else {
-					return c.JSON(http.StatusOK, courses)
-				}
-			},
-			Middlewares: []echo.MiddlewareFunc{
-				apis.ActivityLogger(services.App),
-			},
+	services.App.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		se.Router.GET("/api/courses/events", func(e *core.RequestEvent) error {
+			semester := e.Request.PathValue("semester")
+			courses, err := services.CourseService.GetAllCoursesForSemesterWithEvents(semester)
+			if err != nil {
+				slog.Error("Failed to get courses for semester with events: ", "error", err)
+				return e.JSON(http.StatusBadRequest, "Failed to get courses for semester with events")
+			} else {
+				return e.JSON(http.StatusOK, courses)
+			}
 		})
-		if err != nil {
-			return err
-		}
-		return nil
+		return se.Next()
 	})
 
 	// API Endpoint to get all eventTypes from the database distinct
-	services.App.OnBeforeServe().Add(func(e *core.ServeEvent) error {
-		_, err := e.Router.AddRoute(echo.Route{
-			Method: http.MethodGet,
-			Path:   "/api/events/types",
-			Handler: func(c echo.Context) error {
-				eventTypes, err := services.EventService.GetEventTypes()
-				if err != nil {
-					slog.Error("Failed to get event types", "error", err)
-					return c.JSON(http.StatusBadRequest, "Failed to get event types")
-				} else {
-					return c.JSON(http.StatusOK, eventTypes)
-				}
-			},
-			Middlewares: []echo.MiddlewareFunc{
-				apis.ActivityLogger(services.App),
-			},
+	services.App.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		se.Router.GET("/api/events/types", func(e *core.RequestEvent) error {
+			eventTypes, err := services.EventService.GetEventTypes()
+			if err != nil {
+				slog.Error("Failed to get event types", "error", err)
+				return e.JSON(http.StatusBadRequest, "Failed to get event types")
+			} else {
+				return e.JSON(http.StatusOK, eventTypes)
+			}
 		})
-		if err != nil {
-			return err
-		}
-		return nil
+		return se.Next()
 	})
 
-	services.App.OnBeforeServe().Add(func(e *core.ServeEvent) error {
-		_, err := e.Router.AddRoute(echo.Route{
-			Method: http.MethodDelete,
-			Path:   "/api/events",
-			Handler: func(c echo.Context) error {
-				err := services.EventService.DeleteAllEventsByCourseAndSemester(
-					c.QueryParam("course"),
-					c.QueryParam("semester"),
-				)
-				if err != nil {
-					slog.Error("Failed to delete events: ", "error", err)
-					return c.JSON(http.StatusBadRequest, "Failed to delete events")
-				} else {
-					return c.JSON(http.StatusOK, "Events deleted")
-				}
-			},
-			Middlewares: []echo.MiddlewareFunc{
-				apis.ActivityLogger(services.App),
-				apis.RequireAdminAuth(),
-			},
-		})
-		if err != nil {
-			return err
-		}
-		return nil
+	services.App.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		se.Router.DELETE("/api/events", func(e *core.RequestEvent) error {
+			err := services.EventService.DeleteAllEventsByCourseAndSemester(
+				e.Request.PathValue("course"),
+				e.Request.PathValue("semester"),
+			)
+			if err != nil {
+				slog.Error("Failed to delete events: ", "error", err)
+				return e.JSON(http.StatusBadRequest, "Failed to delete events")
+			} else {
+				return e.JSON(http.StatusOK, "Events deleted")
+			}
+		}).Bind(apis.RequireSuperuserAuth())
+		return se.Next()
 	})
 }