feat:#26 added semester to fetched groups

backend/service/addRoute.go

@@ -307,6 +307,25 @@ func AddRoutes(app *pocketbase.PocketBase) {
 		return nil
 	})
 
+	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")
+				courses := events.GetAllCoursesForSemester(app, semester)
+				return c.JSON(200, courses)
+			},
+			Middlewares: []echo.MiddlewareFunc{
+				apis.ActivityLogger(app),
+			},
+		})
+		if err != nil {
+			return err
+		}
+		return nil
+	})
+
 	app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
 		_, err := e.Router.AddRoute(echo.Route{
 			Method: http.MethodDelete,

backend/service/db/dbGroups.go

@@ -14,7 +14,7 @@ func SaveGroups(seminarGroup []model.SeminarGroup, collection *models.Collection
 	var insertRecords []*models.Record
 
 	for _, group := range seminarGroup {
-		dbGroup, err := FindGroupByCourse(group.Course, app)
+		dbGroup, err := FindGroupByCourseAndSemester(group.Course, group.Semester, app)
 
 		if dbGroup == nil && err.Error() == "sql: no rows in result set" {
 			tobeSavedGroups = append(tobeSavedGroups, group)
@@ -32,6 +32,7 @@ func SaveGroups(seminarGroup []model.SeminarGroup, collection *models.Collection
 		record.Set("course", group.Course)
 		record.Set("faculty", group.Faculty)
 		record.Set("facultyId", group.FacultyId)
+		record.Set("semester", group.Semester)
 		insertRecords = append(insertRecords, record)
 	}
 
@@ -50,13 +51,13 @@ func SaveGroups(seminarGroup []model.SeminarGroup, collection *models.Collection
 	return savedRecords, nil
 }
 
-func FindGroupByCourse(course string, app *pocketbase.PocketBase) (*model.SeminarGroup, error) {
+func FindGroupByCourseAndSemester(course string, semester string, app *pocketbase.PocketBase) (*model.SeminarGroup, error) {
 	var group model.SeminarGroup
-	err := app.Dao().DB().Select("*").From("groups").Where(dbx.NewExp("course = {:course}", dbx.Params{"course": course})).One(&group)
+	err := app.Dao().DB().Select("*").From("groups").Where(dbx.NewExp("course = {:course} AND semester = {:semester}", dbx.Params{"course": course, "semester": semester})).One(&group)
 	if err != nil {
 		return nil, err
 	}
-	return &group, err
+	return &group, nil
 }
 
 func GetAllCourses(app *pocketbase.PocketBase) []string {
@@ -80,3 +81,26 @@ func GetAllCourses(app *pocketbase.PocketBase) []string {
 
 	return courseArray
 }
+
+func GetAllCoursesForSemester(app *pocketbase.PocketBase, semester string) interface{} {
+
+	var courses []struct {
+		CourseShortcut string `db:"course" json:"course"`
+	}
+
+	// get all rooms from event records in the events collection
+	err := app.Dao().DB().Select("course").From("groups").Where(dbx.NewExp("semester = {:semester}", dbx.Params{"semester": semester})).All(&courses)
+	if err != nil {
+		slog.Error("Error while getting groups from database: ", err)
+		return []string{}
+	}
+
+	var courseArray []string
+
+	for _, course := range courses {
+		courseArray = append(courseArray, course.CourseShortcut)
+	}
+
+	return courseArray
+
+}

backend/service/events/courseService.go

@@ -8,3 +8,7 @@ import (
 func GetAllCourses(app *pocketbase.PocketBase) []string {
 	return db.GetAllCourses(app)
 }
+
+func GetAllCoursesForSemester(app *pocketbase.PocketBase, semester string) interface{} {
+	return db.GetAllCoursesForSemester(app, semester)
+}

backend/service/fetch/v1/fetchSeminarGroupService.go

@@ -57,8 +57,8 @@ func FetchSeminarGroups(app *pocketbase.PocketBase) ([]*models.Record, error) {
 		return nil, err
 	}
 
-	groups = parseSeminarGroups(resultSummer)
-	groups = append(groups, parseSeminarGroups(resultWinter)...)
+	groups = parseSeminarGroups(resultSummer, "ss")
+	groups = append(groups, parseSeminarGroups(resultWinter, "ws")...)
 
 	// filter duplicates
 	groups = removeDuplicates(groups)
@@ -91,14 +91,14 @@ func removeDuplicates(groups []model.SeminarGroup) []model.SeminarGroup {
 
 func contains(groups []model.SeminarGroup, group model.SeminarGroup) bool {
 	for _, a := range groups {
-		if a.Course == group.Course {
+		if (a.Course == group.Course) && (a.Semester == group.Semester) {
 			return true
 		}
 	}
 	return false
 }
 
-func parseSeminarGroups(result string) []model.SeminarGroup {
+func parseSeminarGroups(result string, semester string) []model.SeminarGroup {
 
 	var studium model.Studium
 	err := xml.Unmarshal([]byte(result), &studium)
@@ -107,16 +107,17 @@ func parseSeminarGroups(result string) []model.SeminarGroup {
 	}
 
 	var seminarGroups []model.SeminarGroup
-	for _, Fakultaet := range studium.Fakultaet {
-		for _, Studiengang := range Fakultaet.Studiengang {
+	for _, faculty := range studium.Faculty {
+		for _, Studiengang := range faculty.Studiengang {
 			for _, Studienrichtung := range Studiengang.Semgrp {
 				seminarGroup := model.SeminarGroup{
 					University:    "HTWK-Leipzig",
 					GroupShortcut: Studiengang.Name,
 					GroupId:       Studiengang.ID,
 					Course:        Studienrichtung.Name,
-					Faculty:       Fakultaet.Name,
-					FacultyId:     Fakultaet.ID,
+					Faculty:       faculty.Name,
+					FacultyId:     faculty.ID,
+					Semester:      semester,
 				}
 				seminarGroups = append(seminarGroups, seminarGroup)
 			}

backend/service/fetch/v1/fetchSeminarGroupService_test.go

@@ -0,0 +1,75 @@
+package v1
+
+import (
+	"htwkalender/model"
+	"testing"
+)
+
+func Test_contains(t *testing.T) {
+	type args struct {
+		groups []model.SeminarGroup
+		group  model.SeminarGroup
+	}
+	tests := []struct {
+		name string
+		args args
+		want bool
+	}{
+		{
+			name: "should return true if group is in groups",
+			args: args{
+				groups: []model.SeminarGroup{
+					{
+						Course:   "test",
+						Semester: "test",
+					},
+				},
+				group: model.SeminarGroup{
+					Course:   "test",
+					Semester: "test",
+				},
+			},
+			want: true,
+		},
+		{
+			name: "should return false if group is not in groups",
+			args: args{
+				groups: []model.SeminarGroup{
+					{
+						Course:   "test",
+						Semester: "test",
+					},
+				},
+				group: model.SeminarGroup{
+					Course:   "test",
+					Semester: "test2",
+				},
+			},
+			want: false,
+		},
+		{
+			name: "should return false if group is not in courses",
+			args: args{
+				groups: []model.SeminarGroup{
+					{
+						Course:   "test3",
+						Semester: "test",
+					},
+				},
+				group: model.SeminarGroup{
+					Course:   "test",
+					Semester: "test",
+				},
+			},
+			want: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := contains(tt.args.groups, tt.args.group); got != tt.want {
+				t.Errorf("contains() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}