fix:#25 changed course updater insert and delete procedure

backend/service/db/dbEvents.go

@@ -27,24 +27,22 @@ import (
 	"github.com/pocketbase/pocketbase"
 )
 
-func SaveSeminarGroupEvents(seminarGroups []model.SeminarGroup, app *pocketbase.PocketBase) ([]model.Event, error) {
+func SaveSeminarGroupEvents(seminarGroup model.SeminarGroup, app *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 _, seminarGroup := range seminarGroups {
+	for _, event := range seminarGroup.Events {
-		for _, event := range seminarGroup.Events {
+		event = event.SetCourse(seminarGroup.Course)
-			event = event.SetCourse(seminarGroup.Course)
+		existsInDatabase, err := findEventByDayWeekStartEndNameCourse(event, seminarGroup.Course, app)
-			existsInDatabase, err := findEventByDayWeekStartEndNameCourse(event, seminarGroup.Course, app)
+		alreadyAddedToSave := toBeSavedEvents.Contains(event)
-			alreadyAddedToSave := toBeSavedEvents.Contains(event)
 
-			if err != nil {
+		if err != nil {
-				return nil, err
+			return nil, err
-			}
+		}
 
-			if !existsInDatabase && !alreadyAddedToSave {
+		if !existsInDatabase && !alreadyAddedToSave {
-				toBeSavedEvents = append(toBeSavedEvents, event)
+			toBeSavedEvents = append(toBeSavedEvents, event)
-			}
 		}
 	}
 
@@ -366,3 +364,13 @@ func GetEventsThatStartAfterAndEndAfter(app *pocketbase.PocketBase, from types.D
 
 	return events, nil
 }
+
+func DeleteEvents(list model.Events, app *pocketbase.PocketBase) error {
+	for _, event := range list {
+		err := app.Dao().Delete(&event)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

backend/service/events/eventService.go

@@ -22,6 +22,7 @@ import (
 	"htwkalender/service/db"
 	"htwkalender/service/fetch/v1"
 	"htwkalender/service/functions"
+	"log/slog"
 )
 
 func GetModulesForCourseDistinct(app *pocketbase.PocketBase, course string, semester string) (model.Events, error) {
@@ -120,15 +121,11 @@ func DeleteAllEvents(app *pocketbase.PocketBase) error {
 // If the update was not successful, an error is returned
 func UpdateModulesForCourse(app *pocketbase.PocketBase, course string) (model.Events, error) {
 
-	//new string array with one element (course)
+	seminarGroup := v1.GetSeminarGroupEventsFromHTML(course)
-	var courses []string
-	courses = append(courses, course)
 
-	seminarGroups := v1.GetSeminarGroupsEventsFromHTML(courses)
+	seminarGroup = v1.ClearEmptySeminarGroups(seminarGroup)
 
-	seminarGroups = v1.ClearEmptySeminarGroups(seminarGroups)
+	seminarGroup = v1.ReplaceEmptyEventNames(seminarGroup)
-
-	seminarGroups = v1.ReplaceEmptyEventNames(seminarGroups)
 
 	//check if events in the seminarGroups Events are already in the database
 	//if yes, keep the database as it is
@@ -151,43 +148,45 @@ func UpdateModulesForCourse(app *pocketbase.PocketBase, course string) (model.Ev
 
 	//if there are no events in the database, save the new events
 	if len(events) == 0 {
-		events, dbError := db.SaveSeminarGroupEvents(seminarGroups, app)
+		events, dbError := db.SaveSeminarGroupEvents(seminarGroup, app)
 		if dbError != nil {
 			return nil, dbError
 		}
 		return events, nil
 	}
 
-	//check if events in the seminarGroups Events are already in the database
+	// Create partial update list and delete list for the events
-	//if yes, keep the database as it is
+	var insertList model.Events
-	//if no, delete all events for the course and the semester and save the new events
+	var deleteList model.Events
 
-	var savedEvents model.Events
+	// check which events are not already in the database and need to be inserted/saved
-
+	for _, event := range seminarGroup.Events {
-	for _, seminarGroup := range seminarGroups {
+		if !ContainsEvent(events, event) {
-		for _, event := range seminarGroup.Events {
+			insertList = append(insertList, event)
-			// if the event is not in the database, delete all events for the course and the semester and save the new events
-			if !ContainsEvent(events, event) {
-
-				err = DeleteAllEventsByCourseAndSemester(app, course, "ws")
-				if err != nil {
-					return nil, err
-				}
-
-				err = DeleteAllEventsByCourseAndSemester(app, course, "ss")
-				if err != nil {
-					return nil, err
-				}
-
-				//save the new events
-				savedEvent, dbError := db.SaveSeminarGroupEvents(seminarGroups, app)
-				if dbError != nil {
-					return nil, dbError
-				}
-				savedEvents = append(savedEvents, savedEvent...)
-			}
 		}
 	}
+
+	// save all events that are in the insertList
+	savedEvents, err := db.SaveEvents(insertList, app)
+	if err != nil {
+		slog.Error("Failed to save events: %v", err)
+		return nil, err
+	}
+
+	// check which events are in the database but not in the seminarGroup and need to be deleted
+	for _, event := range events {
+		if !ContainsEvent(seminarGroup.Events, event) {
+			deleteList = append(deleteList, event)
+		}
+	}
+
+	// delete all events that are in the deleteList
+	err = db.DeleteEvents(deleteList, app)
+	if err != nil {
+		slog.Error("Failed to delete events: %v", err)
+		return nil, err
+	}
+
 	return savedEvents, nil
 }
 

backend/service/fetch/v1/fetchSeminarEventService.go

@@ -32,50 +32,43 @@ import (
 	"time"
 )
 
-func ReplaceEmptyEventNames(groups []model.SeminarGroup) []model.SeminarGroup {
+func ReplaceEmptyEventNames(group model.SeminarGroup) model.SeminarGroup {
-	for i, group := range groups {
+	for j, event := range group.Events {
-		for j, event := range group.Events {
+		if functions.OnlyWhitespace(event.Name) {
-			if functions.OnlyWhitespace(event.Name) {
+			group.Events[j].Name = "Sonderveranstaltungen"
-				groups[i].Events[j].Name = "Sonderveranstaltungen"
-			}
 		}
 	}
-	return groups
+	return group
 }
 
-func ClearEmptySeminarGroups(seminarGroups []model.SeminarGroup) []model.SeminarGroup {
+func ClearEmptySeminarGroups(seminarGroup model.SeminarGroup) model.SeminarGroup {
-	var newSeminarGroups []model.SeminarGroup
+	var newSeminarGroup = model.SeminarGroup{}
-	for _, seminarGroup := range seminarGroups {
+
-		if len(seminarGroup.Events) > 0 && seminarGroup.Course != "" {
+	if len(seminarGroup.Events) > 0 && seminarGroup.Course != "" {
-			newSeminarGroups = append(newSeminarGroups, seminarGroup)
+		newSeminarGroup = seminarGroup
-		}
 	}
-	return newSeminarGroups
+	return newSeminarGroup
 }
 
-func GetSeminarGroupsEventsFromHTML(seminarGroupsLabel []string) []model.SeminarGroup {
+func GetSeminarGroupEventsFromHTML(seminarGroupLabel string) model.SeminarGroup {
-	var seminarGroups []model.SeminarGroup
+	var seminarGroup model.SeminarGroup
-	for _, seminarGroupLabel := range seminarGroupsLabel {
 
-		if (time.Now().Month() >= 3) && (time.Now().Month() <= 10) {
+	if (time.Now().Month() >= 3) && (time.Now().Month() <= 10) {
-			ssUrl := "https://stundenplan.htwk-leipzig.de/" + string("ss") + "/Berichte/Text-Listen;Studenten-Sets;name;" + seminarGroupLabel + "?template=sws_semgrp&weeks=1-65"
+		ssUrl := "https://stundenplan.htwk-leipzig.de/" + string("ss") + "/Berichte/Text-Listen;Studenten-Sets;name;" + seminarGroupLabel + "?template=sws_semgrp&weeks=1-65"
-			result, getError := fetch.GetHTML(ssUrl)
+		result, getError := fetch.GetHTML(ssUrl)
-			if getError == nil {
+		if getError == nil {
-				seminarGroup := parseSeminarGroup(result)
+			seminarGroup = parseSeminarGroup(result)
-				seminarGroups = append(seminarGroups, seminarGroup)
-			}
-		}
-
-		if (time.Now().Month() >= 9) || (time.Now().Month() <= 4) {
-			wsUrl := "https://stundenplan.htwk-leipzig.de/" + string("ws") + "/Berichte/Text-Listen;Studenten-Sets;name;" + seminarGroupLabel + "?template=sws_semgrp&weeks=1-65"
-			result, getError := fetch.GetHTML(wsUrl)
-			if getError == nil {
-				seminarGroup := parseSeminarGroup(result)
-				seminarGroups = append(seminarGroups, seminarGroup)
-			}
 		}
 	}
-	return seminarGroups
+
+	if (time.Now().Month() >= 9) || (time.Now().Month() <= 4) {
+		wsUrl := "https://stundenplan.htwk-leipzig.de/" + string("ws") + "/Berichte/Text-Listen;Studenten-Sets;name;" + seminarGroupLabel + "?template=sws_semgrp&weeks=1-65"
+		result, getError := fetch.GetHTML(wsUrl)
+		if getError == nil {
+			seminarGroup = parseSeminarGroup(result)
+		}
+	}
+	return seminarGroup
 }
 
 func SplitEventType(events []model.Event) ([]model.Event, error) {

backend/service/fetch/v1/fetchSeminarEventService_test.go

@@ -75,28 +75,17 @@ func Test_extractSemesterAndYear(t *testing.T) {
 
 func Test_replaceEmptyEventNames(t *testing.T) {
 	type args struct {
-		groups []model.SeminarGroup
+		group model.SeminarGroup
 	}
 	tests := []struct {
 		name string
 		args args
-		want []model.SeminarGroup
+		want model.SeminarGroup
 	}{
 		{
 			name: "Test 1",
 			args: args{
-				groups: []model.SeminarGroup{
+				group: model.SeminarGroup{
-					{
-						Events: []model.Event{
-							{
-								Name: "Test",
-							},
-						},
-					},
-				},
-			},
-			want: []model.SeminarGroup{
-				{
 					Events: []model.Event{
 						{
 							Name: "Test",
@@ -104,26 +93,29 @@ func Test_replaceEmptyEventNames(t *testing.T) {
 					},
 				},
 			},
+			want: model.SeminarGroup{
+				Events: []model.Event{
+					{
+						Name: "Test",
+					},
+				},
+			},
 		},
 		{
 			name: "Test 1",
 			args: args{
-				groups: []model.SeminarGroup{
+				group: model.SeminarGroup{
-					{
+					Events: []model.Event{
-						Events: []model.Event{
+						{
-							{
+							Name: "",
-								Name: "",
-							},
 						},
 					},
 				},
 			},
-			want: []model.SeminarGroup{
+			want: model.SeminarGroup{
-				{
+				Events: []model.Event{
-					Events: []model.Event{
+					{
-						{
+						Name: "Sonderveranstaltungen",
-							Name: "Sonderveranstaltungen",
-						},
 					},
 				},
 			},
@@ -131,7 +123,7 @@ func Test_replaceEmptyEventNames(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if got := ReplaceEmptyEventNames(tt.args.groups); !reflect.DeepEqual(got, tt.want) {
+			if got := ReplaceEmptyEventNames(tt.args.group); !reflect.DeepEqual(got, tt.want) {
 				t.Errorf("ReplaceEmptyEventNames() = %v, want %v", got, tt.want)
 			}
 		})