feat:#65 updated backend deps

services/data-manager/service/addCalDavRoutes.go

@@ -17,9 +17,7 @@
 package service
 
 import (
-	"github.com/labstack/echo/v5"
 	"github.com/pocketbase/pocketbase"
-	"github.com/pocketbase/pocketbase/apis"
 	"github.com/pocketbase/pocketbase/core"
 	"htwkalender/data-manager/service/feed"
 	"htwkalender/data-manager/service/ical"
@@ -29,50 +27,30 @@ import (
 )
 
 func addFeedRoutes(app *pocketbase.PocketBase) {
-	app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
-		_, err := e.Router.AddRoute(echo.Route{
-			Method: http.MethodPost,
-			Path:   "/api/feed",
-			Handler: func(c echo.Context) error {
-				requestBody, _ := io.ReadAll(c.Request().Body)
-				result, err := ical.CreateIndividualFeed(requestBody, app)
-				if err != nil {
-					slog.Error("Failed to create individual feed", "error", err)
-					return c.JSON(http.StatusInternalServerError, "Failed to create individual feed")
-				}
-				return c.JSON(http.StatusOK, result)
-			},
-			Middlewares: []echo.MiddlewareFunc{
-				apis.ActivityLogger(app),
-			},
+	app.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		se.Router.POST("/api/feed", func(e *core.RequestEvent) error {
+			requestBody, _ := io.ReadAll(e.Request.Body)
+			result, err := ical.CreateIndividualFeed(requestBody, app)
+			if err != nil {
+				slog.Error("Failed to create individual feed", "error", err)
+				return e.JSON(http.StatusInternalServerError, "Failed to create individual feed")
+			}
+			return e.JSON(http.StatusOK, result)
 		})
-		if err != nil {
-			return err
-		}
-		return nil
+		return se.Next()
 	})
 
-	app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
-		_, err := e.Router.AddRoute(echo.Route{
-			Method: http.MethodDelete,
-			Path:   "/api/feed",
-			Handler: func(c echo.Context) error {
-				token := c.QueryParam("token")
-				err := feed.MarkFeedForDeletion(app.Dao(), token)
-				if err != nil {
-					return c.JSON(http.StatusNotFound, err)
-				} else {
-					return c.JSON(http.StatusOK, "Feed deleted")
-				}
-			},
-			Middlewares: []echo.MiddlewareFunc{
-				apis.ActivityLogger(app),
-			},
+	app.OnServe().BindFunc(func(se *core.ServeEvent) error {
+		se.Router.DELETE("/api/feed", func(e *core.RequestEvent) error {
+			token := e.Request.PathValue("token")
+			err := feed.MarkFeedForDeletion(app, token)
+			if err != nil {
+				return e.JSON(http.StatusNotFound, err)
+			} else {
+				return e.JSON(http.StatusOK, "Feed deleted")
+			}
 		})
-		if err != nil {
-			return err
-		}
-		return nil
+		return se.Next()
 	})
 
 }

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()
 	})
 }

services/data-manager/service/addSchedule.go

@@ -17,8 +17,6 @@
 package service
 
 import (
-	"github.com/pocketbase/pocketbase/core"
-	"github.com/pocketbase/pocketbase/tools/cron"
 	"htwkalender/data-manager/model/serviceModel"
 	"htwkalender/data-manager/service/course"
 	"htwkalender/data-manager/service/feed"
@@ -32,56 +30,47 @@ import (
 
 func AddSchedules(services serviceModel.Service) {
 
-	services.App.OnBeforeServe().Add(func(e *core.ServeEvent) error {
-		scheduler := cron.New()
+	services.App.Cron().MustAdd("updateCourses", "0 22 * * 0", func() {
+		slog.Info("Started updating courses schedule")
+		groups, err := v1.FetchSeminarGroups(services.App)
+		if err != nil {
+			slog.Warn("Failed to fetch seminar groups: ", "error", err)
+		}
+		slog.Info("Successfully fetched " + strconv.FormatInt(int64(len(groups)), 10) + " seminar groups")
+	})
 
-		// !! IMPORTANT !! CRON is based on UTC time zone so in Germany it is UTC+2 in summer and UTC+1 in winter
+	// Every day at 5am and 5pm update all courses (5 segments - minute, hour, day, month, weekday) "0 5,17 * * *"
+	// In Germany it is 7am and 7pm, syllabus gets updated twice a day at German 5:00 Uhr and 17:00 Uhr
+	services.App.Cron().MustAdd("updateEventsByCourse", "0 5,17 * * *", func() {
+		slog.Info("Started updating courses schedule")
+		clock := time.RealClock{}
+		course.UpdateCourse(services, clock)
+	})
 
-		// Every sunday at 10pm update all courses (5 segments - minute, hour, day, month, weekday) "0 22 * * 0"
-		scheduler.MustAdd("updateCourses", "0 22 * * 0", func() {
-			slog.Info("Started updating courses schedule")
-			groups, err := v1.FetchSeminarGroups(services.App)
-			if err != nil {
-				slog.Warn("Failed to fetch seminar groups: ", "error", err)
-			}
-			slog.Info("Successfully fetched " + strconv.FormatInt(int64(len(groups)), 10) + " seminar groups")
-		})
+	// Every sunday at 1am clean all courses (5 segments - minute, hour, day, month, weekday) "0 3 * * 0"
+	services.App.Cron().MustAdd("cleanFeeds", "0 1 * * 0", func() {
+		// clean feeds older than 6 months
+		slog.Info("Started cleaning feeds schedule")
+		feed.ClearFeeds(services.App, 6, time.RealClock{})
+	})
 
-		// Every day at 5am and 5pm update all courses (5 segments - minute, hour, day, month, weekday) "0 5,17 * * *"
-		// In Germany it is 7am and 7pm, syllabus gets updated twice a day at German 5:00 Uhr and 17:00 Uhr
-		scheduler.MustAdd("updateEventsByCourse", "0 5,17 * * *", func() {
-			slog.Info("Started updating courses schedule")
-			clock := time.RealClock{}
-			course.UpdateCourse(services, clock)
-		})
+	// Every sunday at 3am fetch all sport events (5 segments - minute, hour, day, month, weekday) "0 2 * * 0"
+	services.App.Cron().MustAdd("fetchSportEvents", "0 3 * * 0", func() {
+		slog.Info("Started fetching sport events schedule")
+		sportEvents, err := sport.FetchAndUpdateSportEvents(services.App)
+		if err != nil {
+			slog.Error("Failed to fetch and save sport events:", "error", err)
+		}
+		slog.Info("Successfully fetched " + strconv.FormatInt(int64(len(sportEvents)), 10) + " sport events")
+	})
 
-		// Every sunday at 1am clean all courses (5 segments - minute, hour, day, month, weekday) "0 3 * * 0"
-		scheduler.MustAdd("cleanFeeds", "0 1 * * 0", func() {
-			// clean feeds older than 6 months
-			slog.Info("Started cleaning feeds schedule")
-			feed.ClearFeeds(services.App.Dao(), 6, time.RealClock{})
-		})
-
-		// Every sunday at 3am fetch all sport events (5 segments - minute, hour, day, month, weekday) "0 2 * * 0"
-		scheduler.MustAdd("fetchSportEvents", "0 3 * * 0", func() {
-			slog.Info("Started fetching sport events schedule")
-			sportEvents, err := sport.FetchAndUpdateSportEvents(services.App)
-			if err != nil {
-				slog.Error("Failed to fetch and save sport events:", "error", err)
-			}
-			slog.Info("Successfully fetched " + strconv.FormatInt(int64(len(sportEvents)), 10) + " sport events")
-		})
-
-		//fetch all events for semester and delete  from remote this should be done every sunday at 2am
-		scheduler.MustAdd("fetchEvents", "0 22 * * 6", func() {
-			savedEvents, err := v2.FetchAllEventsAndSave(services.App, time.RealClock{})
-			if err != nil {
-				slog.Error("Failed to fetch and save events: ", "error", err)
-			} else {
-				slog.Info("Successfully fetched " + strconv.FormatInt(int64(len(savedEvents)), 10) + " events")
-			}
-		})
-		scheduler.Start()
-		return nil
+	//fetch all events for semester and delete  from remote this should be done every sunday at 2am
+	services.App.Cron().MustAdd("fetchEvents", "0 22 * * 6", func() {
+		savedEvents, err := v2.FetchAllEventsAndSave(services.App, time.RealClock{})
+		if err != nil {
+			slog.Error("Failed to fetch and save events: ", "error", err)
+		} else {
+			slog.Info("Successfully fetched " + strconv.FormatInt(int64(len(savedEvents)), 10) + " events")
+		}
 	})
 }

services/data-manager/service/db/dbEvents.go

@@ -19,7 +19,7 @@ package db
 import (
 	"fmt"
 	"github.com/google/uuid"
-	"github.com/pocketbase/pocketbase/daos"
+	"github.com/pocketbase/pocketbase/core"
 	"github.com/pocketbase/pocketbase/tools/types"
 	"htwkalender/data-manager/model"
 	"log/slog"
@@ -36,7 +36,7 @@ func SaveSeminarGroupEvents(seminarGroup model.SeminarGroup, app *pocketbase.Poc
 	// check if event is already in database and add to toBeSavedEvents if not
 	for _, event := range seminarGroup.Events {
 		event = event.SetCourse(seminarGroup.Course)
-		existsInDatabase, err := findEventByDayWeekStartEndNameCourse(event, seminarGroup.Course, app.Dao())
+		existsInDatabase, err := findEventByDayWeekStartEndNameCourse(event, seminarGroup.Course, app)
 		alreadyAddedToSave := toBeSavedEvents.Contains(event)
 
 		if err != nil {
@@ -52,7 +52,7 @@ func SaveSeminarGroupEvents(seminarGroup model.SeminarGroup, app *pocketbase.Poc
 	for _, event := range toBeSavedEvents {
 		event.MarkAsNew()
 		// auto mapping for event fields to record fields
-		err := app.Dao().Save(&event)
+		err := app.Save(&event)
 		if err != nil {
 			return nil, err
 		} else {
@@ -63,13 +63,13 @@ func SaveSeminarGroupEvents(seminarGroup model.SeminarGroup, app *pocketbase.Poc
 	return savedRecords, nil
 }
 
-func SaveEvents(events []model.Event, txDao *daos.Dao) ([]model.Event, error) {
+func SaveEvents(events []model.Event, base *pocketbase.PocketBase) ([]model.Event, error) {
 	var toBeSavedEvents model.Events
 	var savedRecords model.Events
 
 	// check if event is already in database and add to toBeSavedEvents if not
 	for _, event := range events {
-		existsInDatabase, err := findEventByDayWeekStartEndNameCourse(event, event.Course, txDao)
+		existsInDatabase, err := findEventByDayWeekStartEndNameCourse(event, event.Course, base)
 		alreadyAddedToSave := toBeSavedEvents.Contains(event)
 
 		if err != nil {
@@ -84,7 +84,7 @@ func SaveEvents(events []model.Event, txDao *daos.Dao) ([]model.Event, error) {
 	for _, event := range toBeSavedEvents {
 		event.MarkAsNew()
 		// auto mapping for event fields to record fields
-		err := txDao.Save(&event)
+		err := base.Save(&event)
 		if err != nil {
 			return nil, err
 		} else {
@@ -95,11 +95,11 @@ func SaveEvents(events []model.Event, txDao *daos.Dao) ([]model.Event, error) {
 }
 
 // check if event is already in database and return true if it is and false if it's not
-func findEventByDayWeekStartEndNameCourse(event model.Event, course string, dao *daos.Dao) (bool, error) {
+func findEventByDayWeekStartEndNameCourse(event model.Event, course string, base *pocketbase.PocketBase) (bool, error) {
 
 	var dbEvent model.Event
 
-	err := dao.DB().Select("*").From("events").
+	err := base.DB().Select("*").From("events").
 		Where(dbx.NewExp(
 			"Day = {:day} AND "+
 				"Week = {:week} AND "+
@@ -191,7 +191,7 @@ func GetPlanForModules(app *pocketbase.PocketBase, modules []string) (model.Even
 
 		var selectedModulesQuery = buildIcalQueryForModules(moduleBatch)
 		// get all events from event records in the events collection
-		err := app.Dao().DB().Select("*").From("events").Where(selectedModulesQuery).OrderBy("start").All(&events)
+		err := app.DB().Select("*").From("events").Where(selectedModulesQuery).OrderBy("start").All(&events)
 		if err != nil {
 			return nil, err
 		}
@@ -204,20 +204,7 @@ func GetAllEventsForCourse(app *pocketbase.PocketBase, course string) (model.Eve
 	var events model.Events
 
 	// get all events from event records in the events collection
-	err := app.Dao().DB().Select("*").From("events").Where(dbx.NewExp("course = {:course}", dbx.Params{"course": course})).All(&events)
-	if err != nil {
-		slog.Error("Error while getting events from database: ", "error", err)
-		return nil, fmt.Errorf("error while getting events from database for course %s", course)
-	}
-
-	return events, nil
-}
-
-func GetAllEventsForCourseAndSemester(app *pocketbase.PocketBase, course string, semester string) (model.Events, error) {
-	var events model.Events
-
-	// get all events from event records in the events collection
-	err := app.Dao().DB().Select("*").From("events").Where(dbx.NewExp("course = {:course} AND semester = {:semester}", dbx.Params{"course": course, "semester": semester})).All(&events)
+	err := app.DB().Select("*").From("events").Where(dbx.NewExp("course = {:course}", dbx.Params{"course": course})).All(&events)
 	if err != nil {
 		slog.Error("Error while getting events from database: ", "error", err)
 		return nil, fmt.Errorf("error while getting events from database for course %s", course)
@@ -230,7 +217,7 @@ func GetAllModulesForCourse(app *pocketbase.PocketBase, course string, semester
 	var events model.Events
 
 	// get all events from event records in the events collection
-	err := app.Dao().DB().Select("*").From("events").Where(dbx.NewExp("course = {:course} AND semester = {:semester}", dbx.Params{"course": course, "semester": semester})).GroupBy("Name").Distinct(true).All(&events)
+	err := app.DB().Select("*").From("events").Where(dbx.NewExp("course = {:course} AND semester = {:semester}", dbx.Params{"course": course, "semester": semester})).GroupBy("Name").Distinct(true).All(&events)
 	if err != nil {
 		slog.Error("Error while getting events from database: ", "error", err)
 		return nil, fmt.Errorf("error while getting events from database for course %s and semester %s", course, semester)
@@ -242,7 +229,7 @@ func GetAllModulesForCourse(app *pocketbase.PocketBase, course string, semester
 func GetAllModulesDistinctByNameAndCourse(app *pocketbase.PocketBase) ([]model.ModuleDTO, error) {
 	var modules []model.ModuleDTO
 
-	err := app.Dao().DB().Select("Name", "EventType", "Prof", "course", "semester", "uuid").From("events").GroupBy("Name", "Course").Distinct(true).All(&modules)
+	err := app.DB().Select("Name", "EventType", "Prof", "course", "semester", "uuid").From("events").GroupBy("Name", "Course").Distinct(true).All(&modules)
 	if err != nil {
 		slog.Error("Error while getting events from database: ", "error", err)
 		return nil, fmt.Errorf("error while getting events distinct by name and course from data")
@@ -251,8 +238,8 @@ func GetAllModulesDistinctByNameAndCourse(app *pocketbase.PocketBase) ([]model.M
 	return modules, nil
 }
 
-func DeleteAllEventsByCourse(dao *daos.Dao, course string, semester string) error {
-	_, err := dao.DB().Delete("events", dbx.NewExp("course = {:course} AND semester = {:semester}", dbx.Params{"course": course, "semester": semester})).Execute()
+func DeleteAllEventsByCourse(base *pocketbase.PocketBase, course string, semester string) error {
+	_, err := base.DB().Delete("events", dbx.NewExp("course = {:course} AND semester = {:semester}", dbx.Params{"course": course, "semester": semester})).Execute()
 
 	if err != nil {
 		return err
@@ -260,8 +247,8 @@ func DeleteAllEventsByCourse(dao *daos.Dao, course string, semester string) erro
 	return nil
 }
 
-func DeleteAllEventsRatherThenCourse(dao *daos.Dao, course string, semester string) error {
-	_, err := dao.DB().Delete("events", dbx.NewExp("course != {:course} AND semester = {:semester}", dbx.Params{"course": course, "semester": semester})).Execute()
+func DeleteAllEventsRatherThenCourse(app core.App, course string, semester string) error {
+	_, err := app.DB().Delete("events", dbx.NewExp("course != {:course} AND semester = {:semester}", dbx.Params{"course": course, "semester": semester})).Execute()
 
 	if err != nil {
 		return err
@@ -269,9 +256,9 @@ func DeleteAllEventsRatherThenCourse(dao *daos.Dao, course string, semester stri
 	return nil
 }
 
-func DeleteAllEvents(app *pocketbase.PocketBase) error {
+func DeleteAllEvents(app core.App) error {
 
-	_, err := app.Dao().DB().Delete("events", dbx.NewExp("1=1")).Execute()
+	_, err := app.DB().Delete("events", dbx.NewExp("1=1")).Execute()
 
 	if err != nil {
 		return err
@@ -283,7 +270,7 @@ func DeleteAllEvents(app *pocketbase.PocketBase) error {
 func FindModuleByUUID(app *pocketbase.PocketBase, uuid string) (model.Module, error) {
 	var module model.Module
 
-	err := app.Dao().DB().Select("*").From("events").Where(dbx.NewExp("uuid = {:uuid}", dbx.Params{"uuid": uuid})).One(&module)
+	err := app.DB().Select("*").From("events").Where(dbx.NewExp("uuid = {:uuid}", dbx.Params{"uuid": uuid})).One(&module)
 	if err != nil {
 		return model.Module{}, err
 	}
@@ -294,7 +281,7 @@ func FindModuleByUUID(app *pocketbase.PocketBase, uuid string) (model.Module, er
 func FindAllEventsByModule(app *pocketbase.PocketBase, module model.Module) (model.Events, error) {
 	var events model.Events
 
-	err := app.Dao().DB().Select("*").From("events").Where(dbx.NewExp("Name = {:moduleName} AND course = {:course}", dbx.Params{"moduleName": module.Name, "course": module.Course})).All(&events)
+	err := app.DB().Select("*").From("events").Where(dbx.NewExp("Name = {:moduleName} AND course = {:course}", dbx.Params{"moduleName": module.Name, "course": module.Course})).All(&events)
 	if err != nil {
 		return nil, err
 	}
@@ -305,7 +292,7 @@ func FindAllEventsByModule(app *pocketbase.PocketBase, module model.Module) (mod
 func GetAllModulesByNameAndDateRange(app *pocketbase.PocketBase, name string, startDate time.Time, endDate time.Time) (model.Events, error) {
 	var events model.Events
 
-	err := app.Dao().DB().Select("*").From("events").Where(dbx.NewExp("Name = {:name} AND Start >= {:startDate} AND End <= {:endDate}", dbx.Params{"name": name, "startDate": startDate, "endDate": endDate})).All(&events)
+	err := app.DB().Select("*").From("events").Where(dbx.NewExp("Name = {:name} AND Start >= {:startDate} AND End <= {:endDate}", dbx.Params{"name": name, "startDate": startDate, "endDate": endDate})).All(&events)
 	if err != nil {
 		return nil, err
 	}
@@ -355,7 +342,7 @@ func GetEventsThatCollideWithTimeRange(app *pocketbase.PocketBase, from time.Tim
 func GetEventsThatStartBeforeAndEndAfter(app *pocketbase.PocketBase, from types.DateTime, to types.DateTime) (model.Events, error) {
 	var events model.Events
 
-	err := app.Dao().DB().Select("*").From("events").Where(dbx.NewExp("Start <= {:startDate} AND End >= {:endDate} AND Start <= {:endDate} AND End >= {:startDate}", dbx.Params{"startDate": from, "endDate": to})).Distinct(true).All(&events)
+	err := app.DB().Select("*").From("events").Where(dbx.NewExp("Start <= {:startDate} AND End >= {:endDate} AND Start <= {:endDate} AND End >= {:startDate}", dbx.Params{"startDate": from, "endDate": to})).Distinct(true).All(&events)
 
 	if err != nil {
 		return nil, err
@@ -367,7 +354,7 @@ func GetEventsThatStartBeforeAndEndAfter(app *pocketbase.PocketBase, from types.
 func GetEventsThatStartAfterAndEndBefore(app *pocketbase.PocketBase, from types.DateTime, to types.DateTime) (model.Events, error) {
 	var events model.Events
 
-	err := app.Dao().DB().Select("*").From("events").Where(dbx.NewExp("Start >= {:startDate} AND End <= {:endDate} AND Start <= {:endDate} AND End >= {:startDate}", dbx.Params{"startDate": from, "endDate": to})).All(&events)
+	err := app.DB().Select("*").From("events").Where(dbx.NewExp("Start >= {:startDate} AND End <= {:endDate} AND Start <= {:endDate} AND End >= {:startDate}", dbx.Params{"startDate": from, "endDate": to})).All(&events)
 
 	if err != nil {
 		return nil, err
@@ -379,7 +366,7 @@ func GetEventsThatStartAfterAndEndBefore(app *pocketbase.PocketBase, from types.
 func GetEventsThatStartBeforeAndEndBefore(app *pocketbase.PocketBase, from types.DateTime, to types.DateTime) (model.Events, error) {
 	var events model.Events
 
-	err := app.Dao().DB().Select("*").From("events").Where(dbx.NewExp("Start <= {:startDate} AND End <= {:endDate} AND Start <= {:endDate} AND End >= {:startDate}", dbx.Params{"startDate": from, "endDate": to})).All(&events)
+	err := app.DB().Select("*").From("events").Where(dbx.NewExp("Start <= {:startDate} AND End <= {:endDate} AND Start <= {:endDate} AND End >= {:startDate}", dbx.Params{"startDate": from, "endDate": to})).All(&events)
 
 	if err != nil {
 		return nil, err
@@ -391,7 +378,7 @@ func GetEventsThatStartBeforeAndEndBefore(app *pocketbase.PocketBase, from types
 func GetAllEventTypes(app *pocketbase.PocketBase) ([]model.EventType, error) {
 	var eventTypes []model.EventType
 
-	err := app.Dao().DB().Select("EventType").From("events").GroupBy("EventType").Distinct(true).All(&eventTypes)
+	err := app.DB().Select("EventType").From("events").GroupBy("EventType").Distinct(true).All(&eventTypes)
 	if err != nil {
 		return nil, err
 	}
@@ -401,7 +388,7 @@ func GetAllEventTypes(app *pocketbase.PocketBase) ([]model.EventType, error) {
 
 func GetEventsThatStartAfterAndEndAfter(app *pocketbase.PocketBase, from types.DateTime, to types.DateTime) (model.Events, error) {
 	var events model.Events
-	err := app.Dao().DB().Select("*").From("events").Where(dbx.NewExp("Start >= {:startDate} AND End >= {:endDate} AND Start <= {:endDate} AND End >= {:startDate}", dbx.Params{"startDate": from, "endDate": to})).All(&events)
+	err := app.DB().Select("*").From("events").Where(dbx.NewExp("Start >= {:startDate} AND End >= {:endDate} AND Start <= {:endDate} AND End >= {:startDate}", dbx.Params{"startDate": from, "endDate": to})).All(&events)
 
 	if err != nil {
 		return nil, err
@@ -412,7 +399,7 @@ func GetEventsThatStartAfterAndEndAfter(app *pocketbase.PocketBase, from types.D
 
 func DeleteEvents(list model.Events, app *pocketbase.PocketBase) error {
 	for _, event := range list {
-		err := app.Dao().Delete(&event)
+		err := app.Delete(&event)
 		if err != nil {
 			return err
 		}

services/data-manager/service/db/dbFeeds.go

@@ -20,16 +20,15 @@ import (
 	"errors"
 	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase"
-	"github.com/pocketbase/pocketbase/daos"
-	"github.com/pocketbase/pocketbase/models"
+	"github.com/pocketbase/pocketbase/core"
 	"htwkalender/data-manager/model"
 	"time"
 )
 
-func SaveFeed(feed model.Feed, collection *models.Collection, app *pocketbase.PocketBase) (*models.Record, error) {
-	record := models.NewRecord(collection)
+func SaveFeed(feed model.Feed, collection *core.Collection, app *pocketbase.PocketBase) (*core.Record, error) {
+	record := core.NewRecord(collection)
 	record.Set("modules", feed.Modules)
-	err := app.Dao().SaveRecord(record)
+	err := app.Save(record)
 
 	if err != nil {
 		return nil, err
@@ -39,7 +38,7 @@ func SaveFeed(feed model.Feed, collection *models.Collection, app *pocketbase.Po
 
 func FindFeedByToken(app *pocketbase.PocketBase, token string) (*model.Feed, error) {
 
-	record, err := app.Dao().FindRecordById("feeds", token)
+	record, err := app.FindRecordById("feeds", token)
 
 	if err != nil {
 		return nil, err
@@ -53,15 +52,15 @@ func FindFeedByToken(app *pocketbase.PocketBase, token string) (*model.Feed, err
 	//update retrieved time if the is not marked as deleted
 	if !record.GetBool("deleted") {
 		record.Set("retrieved", time.Now())
-		err = app.Dao().SaveRecord(record)
+		err = app.Save(record)
 	}
 
 	return &feed, err
 }
 
-func DeleteFeed(db *daos.Dao, feedId string) error {
+func DeleteFeed(base *pocketbase.PocketBase, feedId string) error {
 
-	sqlResult, err := db.DB().Delete("feeds", dbx.NewExp("id = {:id}", dbx.Params{"id": feedId})).Execute()
+	sqlResult, err := base.DB().Delete("feeds", dbx.NewExp("id = {:id}", dbx.Params{"id": feedId})).Execute()
 	var deletedRows int64
 	if sqlResult != nil {
 		deletedRows, _ = sqlResult.RowsAffected()
@@ -78,19 +77,19 @@ func DeleteFeed(db *daos.Dao, feedId string) error {
 	}
 }
 
-func GetAllFeeds(db *daos.Dao) ([]model.Feed, error) {
+func GetAllFeeds(base *pocketbase.PocketBase) ([]model.Feed, error) {
 	var feeds []model.Feed
-	err := db.DB().Select("*").From("feeds").All(&feeds)
+	err := base.DB().Select("*").From("feeds").All(&feeds)
 	if err != nil {
 		return nil, err
 	}
 	return feeds, nil
 }
 
-func MarkForDelete(db *daos.Dao, token string) error {
+func MarkForDelete(base *pocketbase.PocketBase, token string) error {
 	// get record from db
 	feed := model.Feed{}
-	err := db.DB().Select("*").From("feeds").Where(dbx.NewExp("id = {:id}", dbx.Params{"id": token})).One(&feed)
+	err := base.DB().Select("*").From("feeds").Where(dbx.NewExp("id = {:id}", dbx.Params{"id": token})).One(&feed)
 	if err != nil {
 		return err
 	}
@@ -99,7 +98,7 @@ func MarkForDelete(db *daos.Dao, token string) error {
 	feed.Modules = "[\n  {\n    \"uuid\": \"\",\n    \"name\": \"Deleted\",\n    \"course\": \"\",\n    \"userDefinedName\": \"Deleted\",\n    \"reminder\": false\n  }\n]"
 
 	// save record
-	err = db.Save(&feed)
+	err = base.Save(&feed)
 	if err != nil {
 		return err
 	}

services/data-manager/service/db/dbFunctions.go

@@ -18,10 +18,10 @@ package db
 
 import (
 	"github.com/pocketbase/pocketbase"
-	"github.com/pocketbase/pocketbase/models"
+	"github.com/pocketbase/pocketbase/core"
 )
 
-func FindCollection(app *pocketbase.PocketBase, collectionName string) (*models.Collection, error) {
-	collection, dbError := app.Dao().FindCollectionByNameOrId(collectionName)
+func FindCollection(app *pocketbase.PocketBase, collectionName string) (*core.Collection, error) {
+	collection, dbError := app.FindCollectionByNameOrId(collectionName)
 	return collection, dbError
 }

services/data-manager/service/db/dbGroups.go

@@ -19,7 +19,7 @@ package db
 import (
 	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase"
-	"github.com/pocketbase/pocketbase/models"
+	"github.com/pocketbase/pocketbase/core"
 	"htwkalender/data-manager/model"
 	"log/slog"
 )
@@ -32,7 +32,7 @@ type SeminarGroup struct {
 	Faculty       string `db:"faculty" json:"faculty"`
 	FacultyId     string `db:"facultyId" json:"facultyId"`
 	Semester      string `db:"semester" json:"semester"`
-	models.BaseModel
+	core.BaseModel
 }
 
 func (s *SeminarGroup) TableName() string {
@@ -69,7 +69,7 @@ type SeminarGroups []*SeminarGroup
 func SaveGroups(seminarGroups SeminarGroups, app *pocketbase.PocketBase) (SeminarGroups, error) {
 
 	// delete all groups from the database
-	execute, err := app.Dao().DB().Delete("groups", dbx.NewExp("1 = 1")).Execute()
+	execute, err := app.DB().Delete("groups", dbx.NewExp("1 = 1")).Execute()
 	if err != nil {
 		return nil, err
 	}
@@ -77,7 +77,7 @@ func SaveGroups(seminarGroups SeminarGroups, app *pocketbase.PocketBase) (Semina
 
 	savedGroups := SeminarGroups{}
 	for _, group := range seminarGroups {
-		saveErr := app.Dao().Save(group)
+		saveErr := app.Save(group)
 		if saveErr != nil {
 			return nil, saveErr
 		}
@@ -95,7 +95,7 @@ func GetAllCourses(app *pocketbase.PocketBase) []string {
 	}
 
 	// get all rooms from event records in the events collection
-	err := app.Dao().DB().Select("course").From("groups").All(&courses)
+	err := app.DB().Select("course").From("groups").All(&courses)
 	if err != nil {
 		slog.Error("Error while getting groups from database: ", "error", err)
 		return []string{}
@@ -115,7 +115,7 @@ func GetAllCoursesForSemester(app *pocketbase.PocketBase, semester string) []mod
 	var courses SeminarGroups
 
 	// get all courses for a specific semester
-	err := app.Dao().DB().Select("*").From("groups").Where(dbx.NewExp("semester = {:semester}", dbx.Params{"semester": semester})).All(&courses)
+	err := app.DB().Select("*").From("groups").Where(dbx.NewExp("semester = {:semester}", dbx.Params{"semester": semester})).All(&courses)
 	if err != nil {
 		slog.Error("Error while getting groups from database: ", "error", err)
 		return nil
@@ -132,7 +132,7 @@ func GetAllCoursesForSemesterWithEvents(app *pocketbase.PocketBase, semester str
 	}
 
 	// get all courses from events distinct for a specific semester
-	err := app.Dao().DB().Select("course").From("events").Where(dbx.NewExp("semester = {:semester}", dbx.Params{"semester": semester})).Distinct(true).All(&courses)
+	err := app.DB().Select("course").From("events").Where(dbx.NewExp("semester = {:semester}", dbx.Params{"semester": semester})).Distinct(true).All(&courses)
 	if err != nil {
 		slog.Error("Error while getting groups from database: ", "error", err)
 		return nil, err
@@ -146,17 +146,3 @@ func GetAllCoursesForSemesterWithEvents(app *pocketbase.PocketBase, semester str
 
 	return courseArray, nil
 }
-
-func FindCourseByCourseName(app *pocketbase.PocketBase, courseName string) (model.SeminarGroup, error) {
-
-	var course SeminarGroup
-
-	// get the course by its name
-	err := app.Dao().DB().Select("*").From("groups").Where(dbx.NewExp("course = {:course}", dbx.Params{"course": courseName})).One(&course)
-	if err != nil {
-		slog.Error("Error while getting group from database: ", "error", err)
-		return model.SeminarGroup{}, err
-	}
-
-	return course.toSeminarGroupModel(), nil
-}

services/data-manager/service/feed/feedFunctions.go

@@ -17,7 +17,7 @@
 package feed
 
 import (
-	"github.com/pocketbase/pocketbase/daos"
+	"github.com/pocketbase/pocketbase"
 	"htwkalender/data-manager/model"
 	database "htwkalender/data-manager/service/db"
 	localTime "htwkalender/data-manager/service/functions/time"
@@ -25,8 +25,8 @@ import (
 	"strings"
 )
 
-func ClearFeeds(db *daos.Dao, months int, clock localTime.Clock) {
-	feeds, err := database.GetAllFeeds(db)
+func ClearFeeds(base *pocketbase.PocketBase, months int, clock localTime.Clock) {
+	feeds, err := database.GetAllFeeds(base)
 	if err != nil {
 		slog.Error("CleanFeeds: failed to get all feeds", "error", err)
 		return
@@ -39,9 +39,9 @@ func ClearFeeds(db *daos.Dao, months int, clock localTime.Clock) {
 
 		if feedRetrievedTime.Before(timeShift) {
 			// delete feed
-			feedErr := database.DeleteFeed(db, feed.GetId())
+			feedErr := database.DeleteFeed(base, feed.Id)
 			if feedErr != nil {
-				slog.Error("CleanFeeds: failed to delete feed: "+feed.GetId(), "error", feedErr)
+				slog.Error("CleanFeeds: failed to delete feed: "+feed.Id, "error", feedErr)
 			}
 		}
 	}
@@ -119,6 +119,6 @@ func combineRooms(events model.Events, index1 int, combinedEvents model.Events,
 	return combinedEvents[index2].Rooms
 }
 
-func MarkFeedForDeletion(db *daos.Dao, feedId string) error {
-	return database.MarkForDelete(db, feedId)
+func MarkFeedForDeletion(base *pocketbase.PocketBase, feedId string) error {
+	return database.MarkForDelete(base, feedId)
 }

services/data-manager/service/fetch/v2/fetcher.go

@@ -20,7 +20,7 @@ import (
 	"fmt"
 	"github.com/google/uuid"
 	"github.com/pocketbase/pocketbase"
-	"github.com/pocketbase/pocketbase/daos"
+	"github.com/pocketbase/pocketbase/core"
 	"golang.org/x/net/html"
 	"htwkalender/data-manager/model"
 	"htwkalender/data-manager/service/db"
@@ -100,19 +100,19 @@ func fetchAndSaveAllEventsForSemester(
 	return savedRecords, err
 }
 
-func updateDatabase(app *pocketbase.PocketBase, eventsToBeAdded []model.Event, course string, semester string) error {
+func updateDatabase(base *pocketbase.PocketBase, eventsToBeAdded []model.Event, course string, semester string) error {
 
 	var addedEvents []model.Event
 	var err error
 
 	// to in transaction the events will be added and deleted
-	err = app.Dao().RunInTransaction(func(txDao *daos.Dao) error {
-		err = db.DeleteAllEventsRatherThenCourse(txDao, course, semester)
+	err = base.App.RunInTransaction(func(app core.App) error {
+		err = db.DeleteAllEventsRatherThenCourse(app, course, semester)
 		if err != nil {
 			return err
 		}
 
-		addedEvents, err = db.SaveEvents(eventsToBeAdded, txDao)
+		addedEvents, err = db.SaveEvents(eventsToBeAdded, base)
 		if err != nil {
 			return err
 		}