Merge branch 'refs/heads/41-bug-all-events-vanish-if-the-official-endpoint-is-offline' into 46-event-update-issue-with-old-courses-in-group-table

# Conflicts:
#	services/data-manager/service/addRoute.go
#	services/data-manager/service/course/courseFunctions.go
#	services/data-manager/service/events/courseService.go
#	services/data-manager/service/events/eventService.go

services/data-manager/service/events/courseService.go

@@ -23,32 +23,51 @@ import (
 	"htwkalender/data-manager/service/functions"
 )
 
-func GetAllCourses(app *pocketbase.PocketBase) []string {
-	return db.GetAllCourses(app)
+// CourseService defines the methods to be implemented
+type CourseService interface {
+	GetAllCourses() []string
+	GetAllCoursesForSemester(semester string) []string
+	GetAllCoursesForSemesterWithEvents(semester string) ([]string, error)
 }
 
-func GetAllCoursesForSemester(app *pocketbase.PocketBase, semester string) []model.SeminarGroup {
-	return db.GetAllCoursesForSemester(app, semester)
+// PocketBaseCourseService is a struct that implements the CourseService interface
+type PocketBaseCourseService struct {
+	app *pocketbase.PocketBase
 }
 
-func GetAllCoursesForSemesterWithEvents(app *pocketbase.PocketBase, semester string) ([]string, error) {
-	courses, err := db.GetAllCoursesForSemesterWithEvents(app, semester)
+// NewPocketBaseCourseService creates a new PocketBaseCourseService
+func NewPocketBaseCourseService(app *pocketbase.PocketBase) *PocketBaseCourseService {
+	return &PocketBaseCourseService{app: app}
+}
+
+// GetAllCourses returns all courses
+func (s *PocketBaseCourseService) GetAllCourses() []string {
+	return db.GetAllCourses(s.app)
+}
+
+// GetAllCoursesForSemester returns all courses for a specific semester
+func (s *PocketBaseCourseService) GetAllCoursesForSemester(semester string) []model.SeminarGroup {
+	return db.GetAllCoursesForSemester(s.app, semester)
+}
+
+// GetAllCoursesForSemesterWithEvents returns all courses for a specific semester with events
+func (s *PocketBaseCourseService) GetAllCoursesForSemesterWithEvents(semester string) ([]string, error) {
+	courses, err := db.GetAllCoursesForSemesterWithEvents(s.app, semester)
 	if err != nil {
 		return nil, err
-	} else {
-		// remove empty courses like " " or ""
-		courses = removeEmptyCourses(courses)
-		return courses, nil
 	}
+	// remove empty courses like " " or ""
+	courses = removeEmptyCourses(courses)
+	return courses, nil
 }
 
 // removeEmptyCourses removes empty courses from the list of courses
 func removeEmptyCourses(courses []string) []string {
 	var filteredCourses []string
 
-	for index, course := range courses {
+	for _, course := range courses {
 		if !functions.OnlyWhitespace(course) || len(course) != 0 {
-			filteredCourses = append(filteredCourses, courses[index])
+			filteredCourses = append(filteredCourses, course)
 		}
 	}
 	return filteredCourses

services/data-manager/service/events/eventService.go

@@ -26,9 +26,31 @@ import (
 	"strconv"
 )
 
-func GetModulesForCourseDistinct(app *pocketbase.PocketBase, course string, semester string) (model.Events, error) {
+type EventService interface {
+	GetModulesForCourseDistinct(course string, semester string) (model.Events, error)
+	GetAllModulesDistinct() ([]model.ModuleDTO, error)
+	GetModuleByUUID(uuid string) (model.Module, error)
+	DeleteAllEventsByCourseAndSemester(course string, semester string) error
+	DeleteAllEvents() error
+	UpdateModulesForCourse(seminarGroup model.SeminarGroup) (model.Events, error)
+	GetEventTypes() ([]string, error)
+}
 
-	modules, err := db.GetAllModulesForCourse(app, course, semester)
+type Named interface {
+	GetName() string
+	SetName(name string)
+}
+
+type PocketBaseEventService struct {
+	app *pocketbase.PocketBase
+}
+
+func NewPocketBaseEventService(app *pocketbase.PocketBase) *PocketBaseEventService {
+	return &PocketBaseEventService{app: app}
+}
+
+func (s *PocketBaseEventService) GetModulesForCourseDistinct(course string, semester string) (model.Events, error) {
+	modules, err := db.GetAllModulesForCourse(s.app, course, semester)
 
 	// Convert the []model.Module to []Named
 	var namedEvents []Named
@@ -40,11 +62,6 @@ func GetModulesForCourseDistinct(app *pocketbase.PocketBase, course string, seme
 	return modules, err
 }
 
-type Named interface {
-	GetName() string
-	SetName(name string)
-}
-
 // replaceEmptyEntry replaces an empty entry in a module with a replacement string
 // If the module is not empty, nothing happens
 func replaceEmptyEntry(namedList []Named, replacement string) {
@@ -57,8 +74,8 @@ func replaceEmptyEntry(namedList []Named, replacement string) {
 
 // GetAllModulesDistinct returns all modules distinct by name and course from the database
 // That means you get all modules with duplicates if they have different courses
-func GetAllModulesDistinct(app *pocketbase.PocketBase) ([]model.ModuleDTO, error) {
-	modules, err := db.GetAllModulesDistinctByNameAndCourse(app)
+func (s *PocketBaseEventService) GetAllModulesDistinct() ([]model.ModuleDTO, error) {
+	modules, err := db.GetAllModulesDistinctByNameAndCourse(s.app)
 	if err != nil {
 		return nil, err
 	}
@@ -70,13 +87,13 @@ func GetAllModulesDistinct(app *pocketbase.PocketBase) ([]model.ModuleDTO, error
 	return modules, nil
 }
 
-func GetModuleByUUID(app *pocketbase.PocketBase, uuid string) (model.Module, error) {
-	module, findModuleErr := db.FindModuleByUUID(app, uuid)
+func (s *PocketBaseEventService) GetModuleByUUID(uuid string) (model.Module, error) {
+	module, findModuleErr := db.FindModuleByUUID(s.app, uuid)
 	if findModuleErr != nil {
 		return model.Module{}, findModuleErr
 	}
 
-	events, findEventsError := db.FindAllEventsByModule(app, module)
+	events, findEventsError := db.FindAllEventsByModule(s.app, module)
 	if findEventsError != nil || len(events) == 0 {
 		return model.Module{}, findEventsError
 	} else {
@@ -94,8 +111,8 @@ func GetModuleByUUID(app *pocketbase.PocketBase, uuid string) (model.Module, err
 // DeleteAllEventsByCourseAndSemester deletes all events for a course and a semester
 // If the deletion was successful, nil is returned
 // If the deletion was not successful, an error is returned
-func DeleteAllEventsByCourseAndSemester(app *pocketbase.PocketBase, course string, semester string) error {
-	err := db.DeleteAllEventsByCourse(app.Dao(), course, semester)
+func (s *PocketBaseEventService) DeleteAllEventsByCourseAndSemester(course string, semester string) error {
+	err := db.DeleteAllEventsByCourse(s.app.Dao(), course, semester)
 	if err != nil {
 		return err
 	} else {
@@ -103,8 +120,8 @@ func DeleteAllEventsByCourseAndSemester(app *pocketbase.PocketBase, course strin
 	}
 }
 
-func DeleteAllEvents(app *pocketbase.PocketBase) error {
-	err := db.DeleteAllEvents(app)
+func (s *PocketBaseEventService) DeleteAllEvents() error {
+	err := db.DeleteAllEvents(s.app)
 	if err != nil {
 		return err
 	} else {
@@ -120,7 +137,7 @@ func DeleteAllEvents(app *pocketbase.PocketBase) error {
 // 3. Save all events for the course and the semester
 // If the update was successful, nil is returned
 // If the update was not successful, an error is returned
-func UpdateModulesForCourse(app *pocketbase.PocketBase, seminarGroup model.SeminarGroup) (model.Events, error) {
+func (s *PocketBaseEventService) UpdateModulesForCourse(seminarGroup model.SeminarGroup) (model.Events, error) {
 
 	seminarGroup, err := v1.FetchAndParse(seminarGroup.Semester, seminarGroup.Course)
 	if err != nil {
@@ -134,14 +151,14 @@ func UpdateModulesForCourse(app *pocketbase.PocketBase, seminarGroup model.Semin
 	//if there are no events in the database, save the new events
 
 	//get all events for the course and the semester
-	dbEvents, err := db.GetAllEventsForCourse(app, seminarGroup.Course)
+	dbEvents, err := db.GetAllEventsForCourse(s.app, seminarGroup.Course)
 	if err != nil {
 		return nil, err
 	}
 
 	//if there are no events in the database, save the new events
 	if len(dbEvents) == 0 {
-		events, dbError := db.SaveSeminarGroupEvents(seminarGroup, app)
+		events, dbError := db.SaveSeminarGroupEvents(seminarGroup, s.app)
 		if dbError != nil {
 			return nil, dbError
 		}
@@ -154,27 +171,27 @@ func UpdateModulesForCourse(app *pocketbase.PocketBase, seminarGroup model.Semin
 
 	// check which events are not already in the database and need to be inserted/saved
 	for _, event := range seminarGroup.Events {
-		if !ContainsEvent(dbEvents, event) {
+		if !containsEvent(dbEvents, event) {
 			insertList = append(insertList, event)
 		}
 	}
 
 	// check which events are in the database but not in the seminarGroup and need to be deleted
 	for _, dbEvent := range dbEvents {
-		if !ContainsEvent(seminarGroup.Events, dbEvent) {
+		if !containsEvent(seminarGroup.Events, dbEvent) {
 			deleteList = append(deleteList, dbEvent)
 		}
 	}
 
 	// delete all events that are in the deleteList
-	err = db.DeleteEvents(deleteList, app)
+	err = db.DeleteEvents(deleteList, s.app)
 	if err != nil {
 		slog.Error("Failed to delete events:", "error", err)
 		return nil, err
 	}
 
 	// save all events that are in the insertList
-	savedEvents, err := db.SaveEvents(insertList, app.Dao())
+	savedEvents, err := db.SaveEvents(insertList, s.app.Dao())
 	if err != nil {
 		slog.Error("Failed to save events: ", "error", err)
 		return nil, err
@@ -184,7 +201,7 @@ func UpdateModulesForCourse(app *pocketbase.PocketBase, seminarGroup model.Semin
 	return savedEvents, nil
 }
 
-func ContainsEvent(events model.Events, event model.Event) bool {
+func containsEvent(events model.Events, event model.Event) bool {
 	for _, e := range events {
 		if e.Name == event.Name &&
 			e.Prof == event.Prof &&
@@ -199,8 +216,8 @@ func ContainsEvent(events model.Events, event model.Event) bool {
 	return false
 }
 
-func GetEventTypes(app *pocketbase.PocketBase) ([]string, error) {
-	dbEventTypes, err := db.GetAllEventTypes(app)
+func (s *PocketBaseEventService) GetEventTypes() ([]string, error) {
+	dbEventTypes, err := db.GetAllEventTypes(s.app)
 	if err != nil {
 		return nil, err
 	}

services/data-manager/service/events/eventService_test.go

@@ -50,8 +50,8 @@ func TestContainsEvent(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if got := ContainsEvent(tt.args.events, tt.args.event); got != tt.want {
-				t.Errorf("ContainsEvent() = %v, want %v", got, tt.want)
+			if got := containsEvent(tt.args.events, tt.args.event); got != tt.want {
+				t.Errorf("containsEvent() = %v, want %v", got, tt.want)
 			}
 		})
 	}

services/data-manager/service/events/mock/courseMock.go

@@ -0,0 +1,66 @@
+package mock
+
+import (
+	"github.com/stretchr/testify/mock"
+	"htwkalender/data-manager/model"
+)
+
+// MockCourseService is a mock implementation of the CourseService interface
+type MockCourseService struct {
+	mock.Mock
+}
+
+func (m *MockCourseService) GetAllCourses() []string {
+	args := m.Called()
+	return args.Get(0).([]string)
+}
+
+func (m *MockCourseService) GetAllCoursesForSemester(semester string) []string {
+	args := m.Called(semester)
+	return args.Get(0).([]string)
+}
+
+func (m *MockCourseService) GetAllCoursesForSemesterWithEvents(semester string) ([]string, error) {
+	args := m.Called(semester)
+	return args.Get(0).([]string), args.Error(1)
+}
+
+// MockEventService is a mock implementation of the EventService interface
+type MockEventService struct {
+	mock.Mock
+}
+
+func (m *MockEventService) GetModulesForCourseDistinct(course string, semester string) (model.Events, error) {
+	args := m.Called(course, semester)
+	return args.Get(0).(model.Events), args.Error(1)
+}
+
+func (m *MockEventService) GetAllModulesDistinct() ([]model.ModuleDTO, error) {
+	args := m.Called()
+	return args.Get(0).([]model.ModuleDTO), args.Error(1)
+}
+
+func (m *MockEventService) GetModuleByUUID(uuid string) (model.Module, error) {
+	args := m.Called(uuid)
+	return args.Get(0).(model.Module), args.Error(1)
+}
+
+func (m *MockEventService) DeleteAllEventsByCourseAndSemester(course string, semester string) error {
+	args := m.Called(course, semester)
+	return args.Error(0)
+}
+
+func (m *MockEventService) DeleteAllEvents() error {
+	args := m.Called()
+	return args.Error(0)
+}
+
+func (m *MockEventService) UpdateModulesForCourse(course string) (model.Events, error) {
+	args := m.Called(course)
+	return args.Get(0).(model.Events), args.Error(1)
+}
+
+func (m *MockEventService) GetEventTypes() ([]string, error) {
+	args := m.Called()
+	return args.Get(0).([]string), args.Error(1)
+}