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

backend/service/addRoute.go

@@ -5,23 +5,17 @@ import (
 	"github.com/pocketbase/pocketbase"
 	"github.com/pocketbase/pocketbase/apis"
 	"github.com/pocketbase/pocketbase/core"
+	"htwkalender/model"
 	"htwkalender/service/events"
 	"htwkalender/service/fetch"
 	"htwkalender/service/ical"
 	"htwkalender/service/room"
 	"io"
 	"net/http"
-	"net/url"
-	"os"
 )
 
 func AddRoutes(app *pocketbase.PocketBase) {
 
-	app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
-		e.Router.GET("/*", apis.StaticDirectoryHandler(os.DirFS("./pb_public"), false))
-		return nil
-	})
-
 	app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
 		_, err := e.Router.AddRoute(echo.Route{
 			Method: http.MethodGet,
@@ -39,6 +33,24 @@ func AddRoutes(app *pocketbase.PocketBase) {
 		return nil
 	})
 
+	app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
+		_, err := e.Router.AddRoute(echo.Route{
+			Method: http.MethodDelete,
+			Path:   "/api/modules",
+			Handler: func(c echo.Context) error {
+				return events.DeleteAllEvents(app)
+			},
+			Middlewares: []echo.MiddlewareFunc{
+				apis.ActivityLogger(app),
+				apis.RequireAdminAuth(),
+			},
+		})
+		if err != nil {
+			return err
+		}
+		return nil
+	})
+
 	app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
 		_, err := e.Router.AddRoute(echo.Route{
 			Method: http.MethodGet,
@@ -199,12 +211,17 @@ func AddRoutes(app *pocketbase.PocketBase) {
 
 	app.OnBeforeServe().Add(func(e *core.ServeEvent) error {
 		_, err := e.Router.AddRoute(echo.Route{
-			Method: http.MethodGet,
+			Method: http.MethodPost,
 			Path:   "/api/module",
 			Handler: func(c echo.Context) error {
-				name := c.Request().Header.Get("Name")
-				name, err := url.QueryUnescape(name)
-				module, err := events.GetModuleByName(app, name)
+
+				var requestModule model.Module
+
+				if err := c.Bind(&requestModule); err != nil {
+					return apis.NewBadRequestError("Failed to read request body", err)
+				}
+
+				module, err := events.GetModuleByName(app, requestModule)
 
 				if err != nil {
 					return c.JSON(400, err)
@@ -263,4 +280,28 @@ 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/feed/migrate",
+			Handler: func(c echo.Context) error {
+				err := ical.MigrateFeedJson(app)
+
+				if err != nil {
+					return c.JSON(500, err)
+				} else {
+					return c.JSON(200, "Migrated")
+				}
+			},
+			Middlewares: []echo.MiddlewareFunc{
+				apis.ActivityLogger(app),
+				apis.RequireAdminAuth(),
+			},
+		})
+		if err != nil {
+			return err
+		}
+		return nil
+	})
 }

backend/service/db/dbEvents.go

@@ -3,78 +3,81 @@ package db
 import (
 	"github.com/pocketbase/dbx"
 	"github.com/pocketbase/pocketbase"
-	"github.com/pocketbase/pocketbase/models"
 	"htwkalender/model"
-	"log"
 )
 
-func SaveEvents(seminarGroup []model.SeminarGroup, collection *models.Collection, app *pocketbase.PocketBase) ([]*models.Record, error) {
-	var toBeSavedEvents []struct {
-		model.Event
-		string
-	}
-	var savedRecords []*models.Record
-	var insertRecords []*models.Record
+func SaveEvents(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 seminarGroup {
 		for _, event := range seminarGroup.Events {
-			dbGroup, err := findEventByDayWeekStartEndNameCourse(event, seminarGroup.Course, app)
+			event = event.SetCourse(seminarGroup.Course)
+			existsInDatabase, err := findEventByDayWeekStartEndNameCourse(event, seminarGroup.Course, app)
+			alreadyAddedToSave := toBeSavedEvents.Contains(event)
 
-			if dbGroup == nil && err.Error() == "sql: no rows in result set" {
-				toBeSavedEvents = append(toBeSavedEvents, struct {
-					model.Event
-					string
-				}{event, seminarGroup.Course})
-			} else if err != nil {
+			if err != nil {
 				return nil, err
 			}
+
+			if !existsInDatabase && !alreadyAddedToSave {
+				toBeSavedEvents = append(toBeSavedEvents, event)
+			}
 		}
 	}
 
 	// create record for each event that's not already in the database
 	for _, event := range toBeSavedEvents {
-		record := models.NewRecord(collection)
-		record.Set("Day", event.Day)
-		record.Set("Week", event.Week)
-		record.Set("Start", event.Start)
-		record.Set("End", event.End)
-		record.Set("Name", event.Name)
-		record.Set("EventType", event.EventType)
-		record.Set("Prof", event.Prof)
-		record.Set("Rooms", event.Rooms)
-		record.Set("Notes", event.Notes)
-		record.Set("BookedAt", event.BookedAt)
-		record.Set("course", event.string)
-		record.Set("semester", event.Semester)
-		insertRecords = append(insertRecords, record)
-	}
-
-	// save all records
-	for _, record := range insertRecords {
-		if record != nil {
-			err := app.Dao().SaveRecord(record)
-			if err == nil {
-				savedRecords = append(savedRecords, record)
-			} else {
-				log.Println("Error while saving record: ", err)
-				return nil, err
-			}
+		event.MarkAsNew()
+		// auto mapping for event fields to record fields
+		err := app.Dao().Save(&event)
+		if err != nil {
+			return nil, err
+		} else {
+			savedRecords = append(savedRecords, event)
 		}
 	}
 
 	return savedRecords, nil
 }
 
-func findEventByDayWeekStartEndNameCourse(event model.Event, course string, app *pocketbase.PocketBase) (*model.Event, error) {
-	err := app.Dao().DB().Select("*").From("events").Where(
-		dbx.NewExp("Day = {:day} AND Week = {:week} AND Start = {:start} AND End = {:end} AND Name = {:name} AND course = {:course} AND Prof = {:prof} AND Rooms = {:rooms} AND EventType = {:eventType}",
-			dbx.Params{"day": event.Day, "week": event.Week, "start": event.Start, "end": event.End, "name": event.Name, "course": course, "prof": event.Prof, "rooms": event.Rooms, "eventType": event.EventType}),
-	).One(&event)
+// check if event is already in database and return true if it is and false if it's not
+func findEventByDayWeekStartEndNameCourse(event model.Event, course string, app *pocketbase.PocketBase) (bool, error) {
+
+	var dbEvent model.Event
+
+	err := app.Dao().DB().Select("*").From("events").
+		Where(dbx.NewExp(
+			"Day = {:day} AND "+
+				"Week = {:week} AND "+
+				"Start = {:start} AND "+
+				"End = {:end} AND "+
+				"Name = {:name} AND "+
+				"course = {:course} AND "+
+				"Prof = {:prof} AND "+
+				"Rooms = {:rooms} AND "+
+				"EventType = {:eventType}",
+			dbx.Params{
+				"day":       event.Day,
+				"week":      event.Week,
+				"start":     event.Start,
+				"end":       event.End,
+				"name":      event.Name,
+				"course":    course,
+				"prof":      event.Prof,
+				"rooms":     event.Rooms,
+				"eventType": event.EventType}),
+		).One(&dbEvent)
+
 	if err != nil {
-		return nil, err
+		if err.Error() == "sql: no rows in result set" {
+			return false, nil
+		}
+		return false, err
+	} else {
+		return true, nil
 	}
-	return &event, err
 }
 
 func buildIcalQueryForModules(modules []model.FeedCollection) dbx.Expression {
@@ -176,10 +179,21 @@ func DeleteAllEventsForCourse(app *pocketbase.PocketBase, course string, semeste
 	return nil
 }
 
-func FindAllEventsByModule(app *pocketbase.PocketBase, moduleName string) (model.Events, error) {
+func DeleteAllEvents(app *pocketbase.PocketBase) error {
+
+	_, err := app.Dao().DB().Delete("events", dbx.NewExp("1=1")).Execute()
+
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func FindAllEventsByModule(app *pocketbase.PocketBase, module model.Module) (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)
+	err := app.Dao().DB().Select("*").From("events").Where(dbx.NewExp("Name = {:moduleName} AND course = {:course}", dbx.Params{"moduleName": module.Name, "course": module.Course})).All(&events)
 	if err != nil {
 		print("Error while getting events from database: ", err)
 		return nil, err

backend/service/events/eventService.go

@@ -46,14 +46,15 @@ func GetAllModulesDistinct(app *pocketbase.PocketBase, c echo.Context) error {
 // If the module does not exist, an error is returned
 // If the module exists, the module is returned
 // Module is a struct that exists in database as events
-func GetModuleByName(app *pocketbase.PocketBase, name string) (model.Module, error) {
-	events, err := db.FindAllEventsByModule(app, name)
+func GetModuleByName(app *pocketbase.PocketBase, module model.Module) (model.Module, error) {
+	events, err := db.FindAllEventsByModule(app, module)
 
 	if err != nil || len(events) == 0 {
 		return model.Module{}, err
 	} else {
 		return model.Module{
-			Name:     name,
+			UUID:     events[0].UUID,
+			Name:     events[0].Name,
 			Events:   events,
 			Prof:     events[0].Prof,
 			Course:   events[0].Course,
@@ -74,6 +75,15 @@ func DeleteAllEventsByCourseAndSemester(app *pocketbase.PocketBase, course strin
 	}
 }
 
+func DeleteAllEvents(app *pocketbase.PocketBase) error {
+	err := db.DeleteAllEvents(app)
+	if err != nil {
+		return err
+	} else {
+		return nil
+	}
+}
+
 // UpdateModulesForCourse updates all modules for a course
 // Does Updates for ws and ss semester sequentially
 // Update runs through the following steps:
@@ -90,11 +100,6 @@ func UpdateModulesForCourse(app *pocketbase.PocketBase, course string) error {
 
 	seminarGroups := fetch.GetSeminarGroupsEventsFromHTML(courses)
 
-	collection, dbError := db.FindCollection(app, "events")
-	if dbError != nil {
-		return apis.NewNotFoundError("Collection not found", dbError)
-	}
-
 	seminarGroups = fetch.ClearEmptySeminarGroups(seminarGroups)
 
 	seminarGroups = fetch.ReplaceEmptyEventNames(seminarGroups)
@@ -120,7 +125,7 @@ func UpdateModulesForCourse(app *pocketbase.PocketBase, course string) error {
 
 	//if there are no events in the database, save the new events
 	if len(events) == 0 {
-		_, dbError = db.SaveEvents(seminarGroups, collection, app)
+		_, dbError := db.SaveEvents(seminarGroups, app)
 		if dbError != nil {
 			return apis.NewNotFoundError("Events could not be saved", dbError)
 		}
@@ -146,7 +151,7 @@ func UpdateModulesForCourse(app *pocketbase.PocketBase, course string) error {
 				}
 
 				//save the new events
-				_, dbError = db.SaveEvents(seminarGroups, collection, app)
+				_, dbError := db.SaveEvents(seminarGroups, app)
 				if dbError != nil {
 					return apis.NewNotFoundError("Events could not be saved", dbError)
 				}

backend/service/fetch/fetchSeminarEventService.go

@@ -2,6 +2,7 @@ package fetch
 
 import (
 	"fmt"
+	"github.com/google/uuid"
 	"github.com/labstack/echo/v5"
 	"github.com/pocketbase/pocketbase"
 	"github.com/pocketbase/pocketbase/apis"
@@ -23,19 +24,14 @@ func GetSeminarEvents(c echo.Context, app *pocketbase.PocketBase) error {
 
 	seminarGroups := GetSeminarGroupsEventsFromHTML(seminarGroupsLabel)
 
-	collection, dbError := db.FindCollection(app, "events")
-	if dbError != nil {
-		return apis.NewNotFoundError("Collection not found", dbError)
-	}
-
 	seminarGroups = ClearEmptySeminarGroups(seminarGroups)
 
 	seminarGroups = ReplaceEmptyEventNames(seminarGroups)
 
-	savedRecords, dbError := db.SaveEvents(seminarGroups, collection, app)
+	savedRecords, dbError := db.SaveEvents(seminarGroups, app)
 
 	if dbError != nil {
-		return apis.NewNotFoundError("Events could not be saved", dbError)
+		return apis.NewNotFoundError("Events could not be saved", dbError.Error())
 	}
 
 	return c.JSON(http.StatusOK, savedRecords)
@@ -100,16 +96,28 @@ func parseSeminarGroup(result string) model.SeminarGroup {
 	splitEventsByWeekVal := splitEventsByWeek(eventsWithCombinedWeeks)
 	events := splitEventsBySingleWeek(splitEventsByWeekVal)
 	semesterString := findFirstSpanWithClass(table, "header-0-2-0").FirstChild.Data
+	course := findFirstSpanWithClass(table, "header-2-0-1").FirstChild.Data
 	semester, year := extractSemesterAndYear(semesterString)
 	events = convertWeeksToDates(events, semester, year)
+	events = generateUUIDs(events, course)
 	var seminarGroup = model.SeminarGroup{
 		University: findFirstSpanWithClass(table, "header-1-0-0").FirstChild.Data,
-		Course:     findFirstSpanWithClass(table, "header-2-0-1").FirstChild.Data,
+		Course:     course,
 		Events:     events,
 	}
 	return seminarGroup
 }
 
+func generateUUIDs(events []model.Event, course string) []model.Event {
+	for i, event := range events {
+		// generate a hash value from the event name, course and semester
+		hash := uuid.NewSHA1(uuid.NameSpaceOID, []byte(event.Name+course))
+		events[i].UUID = hash.String()
+	}
+	return events
+
+}
+
 func convertWeeksToDates(events []model.Event, semester string, year string) []model.Event {
 	var newEvents []model.Event
 	eventYear, _ := strconv.Atoi(year)

backend/service/fetch/fetchSeminarEventService_test.go

@@ -118,3 +118,57 @@ func Test_replaceEmptyEventNames(t *testing.T) {
 		})
 	}
 }
+
+func Test_generateUUIDs(t *testing.T) {
+	type args struct {
+		events []model.Event
+		course string
+	}
+	tests := []struct {
+		name string
+		args args
+		want []model.Event
+	}{
+		{
+			name: "Test 1",
+			args: args{
+				events: []model.Event{
+					{
+						Name: " Arbeitssicherheit / Rechtsformen von Unternehmen B435 SBB  (wpf) & B348 BIB (pf) 5. FS",
+					},
+				},
+				course: "21BIB-2a",
+			},
+			want: []model.Event{
+				{
+					Name: " Arbeitssicherheit / Rechtsformen von Unternehmen B435 SBB  (wpf) & B348 BIB (pf) 5. FS",
+					UUID: "3720afdc-10c7-5b72-9489-cffb70cb0c13",
+				},
+			},
+		},
+		{
+			name: "Test 2",
+			args: args{
+				events: []model.Event{
+					{
+						Name: " Arbeitssicherheit / Rechtsformen von Unternehmen B435 SBB  (wpf) & B348 BIB (pf) 5. FS",
+					},
+				},
+				course: "21BIB-2b",
+			},
+			want: []model.Event{
+				{
+					Name: " Arbeitssicherheit / Rechtsformen von Unternehmen B435 SBB  (wpf) & B348 BIB (pf) 5. FS",
+					UUID: "81083480-bcf1-5452-af84-bb27d79282d8",
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := generateUUIDs(tt.args.events, tt.args.course); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("generateUUIDs() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

backend/service/ical/ical.go

@@ -16,8 +16,6 @@ import (
 const expirationTime = 5 * time.Minute
 
 func Feed(c echo.Context, app *pocketbase.PocketBase, token string) error {
-	layout := "2006-01-02 15:04:05 -0700 MST"
-
 	var result string
 	var responseWriter = c.Response().Writer
 	feed, err := db.FindFeedByToken(token, app)
@@ -25,17 +23,14 @@ func Feed(c echo.Context, app *pocketbase.PocketBase, token string) error {
 		return c.JSON(http.StatusNotFound, err)
 	}
 
-	created, _ := time.Parse(layout, feed.Created)
-
 	var modules []model.FeedCollection
 	_ = json.Unmarshal([]byte(feed.Modules), &modules)
-	if created.Add(time.Hour * 265).Before(time.Now()) {
-		newFeed, err := createFeedForToken(app, modules)
-		if err != nil {
-			return c.JSON(http.StatusInternalServerError, err)
-		}
-		result = newFeed.Content
+
+	newFeed, err := createFeedForToken(app, modules)
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, err)
 	}
+	result = newFeed.Content
 
 	responseWriter.Header().Set("Content-type", "text/calendar")
 	responseWriter.Header().Set("charset", "utf-8")

backend/service/ical/icalFileGeneration.go

@@ -50,7 +50,7 @@ func replaceNameIfUserDefined(name string, mapping []model.FeedCollection) strin
 	return name
 }
 
-func generateDescription(event *model.Event) string {
+func generateDescription(event model.Event) string {
 	var description string
 
 	if !functions.OnlyWhitespace(event.Notes) {

backend/service/ical/icalJsonMigrate.go

@@ -0,0 +1,58 @@
+package ical
+
+import (
+	"encoding/json"
+	"github.com/pocketbase/dbx"
+	"github.com/pocketbase/pocketbase"
+	"htwkalender/model"
+)
+
+//update ical feed json
+//add uuid field
+//remove module name field
+
+func MigrateFeedJson(app *pocketbase.PocketBase) error {
+
+	records, err := app.Dao().FindRecordsByFilter("feeds", "1=1", "-created", 0, 0)
+	if err != nil {
+		return err
+	}
+
+	for _, feed := range records {
+
+		var modules []model.FeedCollection
+
+		err := json.Unmarshal([]byte(feed.GetString("modules")), &modules)
+		if err != nil {
+			return err
+		}
+
+		var uuidFeedCollections []model.FeedCollection
+
+		for _, module := range modules {
+			uuid := searchUUIDForModule(app, module)
+
+			if uuid != "" {
+				uuidFeedCollections = append(uuidFeedCollections, model.FeedCollection{UUID: uuid, Name: module.Name, Course: module.Course, UserDefinedName: module.UserDefinedName})
+			}
+		}
+
+		jsonModules, _ := json.Marshal(uuidFeedCollections)
+		feed.Set("modules", string(jsonModules))
+
+		err = app.Dao().SaveRecord(feed)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func searchUUIDForModule(app *pocketbase.PocketBase, module model.FeedCollection) string {
+	var event model.Event
+	err := app.Dao().DB().Select("*").From("events").Where(dbx.NewExp("Name = {:name} AND course = {:course}", dbx.Params{"name": module.Name, "course": module.Course})).One(&event)
+	if err != nil {
+		return ""
+	}
+	return event.UUID
+}