Merge branch '10-roomfinder' of github.com:masterElmar/htwkalender into 10-roomfinder

backend/service/db/dbEvents.go

@@ -77,74 +77,113 @@ func findEventByDayWeekStartEndNameCourse(event model.Event, course string, app
 	return &event, err
 }
 
+func buildIcalQueryForModules(modules []model.FeedCollection) dbx.Expression {
+
+	// build where conditions for each module
+
+	//first check if modules is empty
+	if len(modules) == 0 {
+		return dbx.HashExp{}
+	}
+
+	//second check if modules has only one element
+	if len(modules) == 1 {
+		return dbx.And(
+			dbx.HashExp{"Name": modules[0].Name},
+			dbx.HashExp{"course": modules[0].Course},
+		)
+	}
+
+	//third check if modules has more than one element
+	var wheres []dbx.Expression
+
+	for _, module := range modules {
+		where := dbx.And(
+			dbx.HashExp{"Name": module.Name},
+			dbx.HashExp{"course": module.Course},
+		)
+		wheres = append(wheres, where)
+	}
+
+	// Use dbx.And or dbx.Or to combine the where conditions as needed
+	where := dbx.Or(wheres...)
+
+	return where
+
+}
+
+// GetPlanForModules returns all events for the given modules with the given course
+// used for the ical feed
 func GetPlanForModules(app *pocketbase.PocketBase, modules []model.FeedCollection) model.Events {
 
-	// build query functions with name equals elements in modules for dbx query
+	var events model.Events
 
-	var queryString string
-	for i, module := range modules {
-		if i == 0 {
-			queryString = "Name = '" + module.Name + "' AND course = '" + module.Course + "'"
+	// iterate over modules in 100 batch sizes
+	for i := 0; i < len(modules); i += 100 {
+		var moduleBatch []model.FeedCollection
+
+		if i+100 > len(modules) {
+			moduleBatch = modules[i:]
 		} else {
-			queryString = queryString + " OR Name = '" + module.Name + "' AND course = '" + module.Course + "'"
+			moduleBatch = modules[i : i+100]
+		}
+
+		var selectedModulesQuery = buildIcalQueryForModules(moduleBatch)
+		// get all events from event records in the events collection
+		err := app.Dao().DB().Select("*").From("events").Where(selectedModulesQuery).All(&events)
+		if err != nil {
+			print("Error while getting events from database: ", err)
+			return nil
 		}
 	}
 
-	var events model.Events
-	// get all events from event records in the events collection
-	err := app.Dao().DB().Select("*").From("events").Where(dbx.NewExp(queryString)).All(&events)
-	if err != nil {
-		print("Error while getting events from database: ", err)
-		return nil
-	}
 	return events
 }
 
-func GetAllModulesForCourse(app *pocketbase.PocketBase, course string, semester string) ([]string, error) {
-	var events []struct {
-		Name string `db:"Name" json:"Name"`
-	}
-
-	var eventArray []string
+func GetAllModulesForCourse(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("Name").From("events").Where(dbx.NewExp("course = {:course} AND semester = {:semester}", dbx.Params{"course": course, "semester": semester})).Distinct(true).All(&events)
+	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)
 	if err != nil {
 		print("Error while getting events from database: ", err)
-		return eventArray, err
+		return nil, err
 	}
 
-	for _, event := range events {
-		eventArray = append(eventArray, event.Name)
-	}
-	return eventArray, nil
+	return events, nil
 }
 
-func GetAllModulesDistinct(app *pocketbase.PocketBase) ([]struct {
-	Name   string
-	Course string
-}, error) {
-	var events []struct {
-		Name   string `db:"Name" json:"Name"`
-		Course string `db:"course" json:"course"`
-	}
+func GetAllModulesDistinctByNameAndCourse(app *pocketbase.PocketBase) (model.Events, error) {
+	var events model.Events
 
-	var eventArray []struct {
-		Name   string
-		Course string
-	}
-
-	err := app.Dao().DB().Select("Name", "course").From("events").Distinct(true).All(&events)
+	err := app.Dao().DB().Select("*").From("events").GroupBy("Name", "course").Distinct(true).All(&events)
 	if err != nil {
 		print("Error while getting events from database: ", err)
-		return eventArray, err
+		return nil, err
 	}
 
-	for _, event := range events {
-		eventArray = append(eventArray, struct {
-			Name   string
-			Course string
-		}{event.Name, event.Course})
-	}
-	return eventArray, nil
+	return events, nil
+}
+
+func DeleteAllEventsForCourse(app *pocketbase.PocketBase, course string, semester string) error {
+	_, err := app.Dao().DB().Delete("events", dbx.NewExp("course = {:course} AND semester = {:semester}", dbx.Params{"course": course, "semester": semester})).Execute()
+
+	if err != nil {
+		print("Error while deleting events from database: ", err)
+		return err
+	}
+
+	return nil
+}
+
+func FindAllEventsByModule(app *pocketbase.PocketBase, moduleName string) (model.Events, error) {
+	var events model.Events
+
+	err := app.Dao().DB().Select("*").From("events").Where(dbx.NewExp("Name = {:moduleName}", dbx.Params{"moduleName": moduleName})).All(&events)
+	if err != nil {
+		print("Error while getting events from database: ", err)
+		return nil, err
+	}
+
+	return events, nil
 }

backend/service/db/dbEvents_test.go

@@ -0,0 +1,42 @@
+package db
+
+import (
+	"github.com/pocketbase/dbx"
+	"htwkalender/model"
+	"reflect"
+	"testing"
+)
+
+func Test_buildIcalQueryForModules(t *testing.T) {
+	type args struct {
+		modules []model.FeedCollection
+	}
+	tests := []struct {
+		name string
+		args args
+		want dbx.Expression
+	}{
+		{
+			name: "empty modules",
+			args: args{modules: []model.FeedCollection{}},
+			want: dbx.HashExp{},
+		},
+		{
+			name: "one module",
+			args: args{modules: []model.FeedCollection{{Name: "test", Course: "test"}}},
+			want: dbx.And(dbx.HashExp{"Name": "test"}, dbx.HashExp{"course": "test"}),
+		},
+		{
+			name: "two modules",
+			args: args{modules: []model.FeedCollection{{Name: "test", Course: "test"}, {Name: "test2", Course: "test2"}}},
+			want: dbx.Or(dbx.And(dbx.HashExp{"Name": "test"}, dbx.HashExp{"course": "test"}), dbx.And(dbx.HashExp{"Name": "test2"}, dbx.HashExp{"course": "test2"})),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := buildIcalQueryForModules(tt.args.modules); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("buildIcalQueryForModules() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}