diff --git a/backend/model/eventModel.go b/backend/model/eventModel.go
index 098c88a..05b3fec 100644
--- a/backend/model/eventModel.go
+++ b/backend/model/eventModel.go
@@ -41,36 +41,44 @@ type Event struct {
 	models.BaseModel
 }
 
-func (m *Event) Equals(event Event) bool {
-	return m.Day == event.Day &&
-		m.Week == event.Week &&
-		m.Start == event.Start &&
-		m.End == event.End &&
-		m.Name == event.Name &&
-		m.Course == event.Course &&
-		m.Prof == event.Prof &&
-		m.Rooms == event.Rooms &&
-		m.EventType == event.EventType
+func (e *Event) Equals(event Event) bool {
+	return e.Day == event.Day &&
+		e.Week == event.Week &&
+		e.Start == event.Start &&
+		e.End == event.End &&
+		e.Name == event.Name &&
+		e.Course == event.Course &&
+		e.Prof == event.Prof &&
+		e.Rooms == event.Rooms &&
+		e.EventType == event.EventType
 }
 
-func (m *Event) TableName() string {
+func (e *Event) TableName() string {
 	return "events"
 }
 
 // SetCourse func to set the course and returns the event
-func (m *Event) SetCourse(course string) Event {
-	m.Course = course
-	return *m
+func (e *Event) SetCourse(course string) Event {
+	e.Course = course
+	return *e
 }
 
 // Creates an AnonymizedEventDTO from an Event hiding all sensitive data
-func (m *Event) AnonymizeEvent() AnonymizedEventDTO {
+func (e *Event) AnonymizeEvent() AnonymizedEventDTO {
 	return AnonymizedEventDTO{
-		Day:   m.Day,
-		Week:  m.Week,
-		Start: m.Start,
-		End:   m.End,
-		Rooms: m.Rooms,
-		Free:  strings.Contains(strings.ToLower(m.Name), "zur freien verfügung"),
+		Day:   e.Day,
+		Week:  e.Week,
+		Start: e.Start,
+		End:   e.End,
+		Rooms: e.Rooms,
+		Free:  strings.Contains(strings.ToLower(e.Name), "zur freien verfügung"),
 	}
 }
+
+func (e *Event) GetName() string {
+	return e.Name
+}
+
+func (e *Event) SetName(name string) {
+	e.Name = name
+}
diff --git a/backend/model/moduleModel.go b/backend/model/moduleModel.go
index 438721e..807d9d4 100644
--- a/backend/model/moduleModel.go
+++ b/backend/model/moduleModel.go
@@ -8,3 +8,24 @@ type Module struct {
 	Semester string `json:"semester" db:"semester"`
 	Events   Events `json:"events"`
 }
+
+func (m *Module) SetName(name string) {
+	m.Name = name
+}
+
+type ModuleDTO struct {
+	UUID      string `json:"uuid" db:"uuid"`
+	Name      string `json:"name" db:"Name"`
+	Prof      string `json:"prof" db:"Prof"`
+	Course    string `json:"course" db:"course"`
+	Semester  string `json:"semester" db:"semester"`
+	EventType string `db:"EventType" json:"eventType"`
+}
+
+func (m *ModuleDTO) GetName() string {
+	return m.Name
+}
+
+func (m *ModuleDTO) SetName(name string) {
+	m.Name = name
+}
diff --git a/backend/service/db/dbEvents.go b/backend/service/db/dbEvents.go
index 37ed4cf..8707063 100644
--- a/backend/service/db/dbEvents.go
+++ b/backend/service/db/dbEvents.go
@@ -189,16 +189,16 @@ func GetAllModulesForCourse(app *pocketbase.PocketBase, course string, semester
 	return events, nil
 }
 
-func GetAllModulesDistinctByNameAndCourse(app *pocketbase.PocketBase) (model.Events, error) {
-	var events model.Events
+func GetAllModulesDistinctByNameAndCourse(app *pocketbase.PocketBase) ([]model.ModuleDTO, error) {
+	var modules []model.ModuleDTO
 
-	err := app.Dao().DB().Select("*").From("events").GroupBy("Name").Distinct(true).All(&events)
+	err := app.Dao().DB().Select("Name", "EventType", "Prof", "course", "semester", "uuid").From("events").GroupBy("Name", "Course").Distinct(true).All(&modules)
 	if err != nil {
 		print("Error while getting events from database: ", err)
 		return nil, err
 	}
 
-	return events, nil
+	return modules, nil
 }
 
 func DeleteAllEventsForCourse(app *pocketbase.PocketBase, course string, semester string) error {
diff --git a/backend/service/events/eventService.go b/backend/service/events/eventService.go
index d6dc97b..c14eb58 100644
--- a/backend/service/events/eventService.go
+++ b/backend/service/events/eventService.go
@@ -13,17 +13,28 @@ import (
 func GetModulesForCourseDistinct(app *pocketbase.PocketBase, course string, semester string) (model.Events, error) {
 
 	modules, err := db.GetAllModulesForCourse(app, course, semester)
-	replaceEmptyEntry(modules, "Sonderveranstaltungen")
+
+	// Convert the []model.Module to []Named
+	var namedEvents []Named
+	for _, module := range modules {
+		namedEvents = append(namedEvents, &module)
+	}
+
+	replaceEmptyEntry(namedEvents, "Sonderveranstaltungen")
 	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(modules model.Events, replacement string) {
-
-	for i, module := range modules {
-		if functions.OnlyWhitespace(module.Name) {
-			modules[i].Name = replacement
+func replaceEmptyEntry(namedList []Named, replacement string) {
+	for i, namedItem := range namedList {
+		if functions.OnlyWhitespace(namedItem.GetName()) {
+			namedList[i].SetName(replacement)
 		}
 	}
 }
@@ -33,7 +44,12 @@ func replaceEmptyEntry(modules model.Events, replacement string) {
 func GetAllModulesDistinct(app *pocketbase.PocketBase, c echo.Context) error {
 	modules, err := db.GetAllModulesDistinctByNameAndCourse(app)
 
-	replaceEmptyEntry(modules, "Sonderveranstaltungen")
+	var namedModules []Named
+	for _, module := range modules {
+		namedModules = append(namedModules, &module)
+	}
+
+	replaceEmptyEntry(namedModules, "Sonderveranstaltungen")
 
 	if err != nil {
 		return c.JSON(400, err)