feat:#16 added uuid and fixed some pointer logic

backend/migrations/1698017941_updated_events.go

@@ -0,0 +1,52 @@
+package migrations
+
+import (
+	"encoding/json"
+
+	"github.com/pocketbase/dbx"
+	"github.com/pocketbase/pocketbase/daos"
+	m "github.com/pocketbase/pocketbase/migrations"
+	"github.com/pocketbase/pocketbase/models/schema"
+)
+
+func init() {
+	m.Register(func(db dbx.Builder) error {
+		dao := daos.New(db)
+
+		collection, err := dao.FindCollectionByNameOrId("7her4515qsmrxe8")
+		if err != nil {
+			return err
+		}
+
+		// add
+		new_uuid := &schema.SchemaField{}
+		json.Unmarshal([]byte(`{
+			"system": false,
+			"id": "0kahthzr",
+			"name": "uuid",
+			"type": "text",
+			"required": false,
+			"unique": false,
+			"options": {
+				"min": null,
+				"max": null,
+				"pattern": ""
+			}
+		}`), new_uuid)
+		collection.Schema.AddField(new_uuid)
+
+		return dao.SaveCollection(collection)
+	}, func(db dbx.Builder) error {
+		dao := daos.New(db)
+
+		collection, err := dao.FindCollectionByNameOrId("7her4515qsmrxe8")
+		if err != nil {
+			return err
+		}
+
+		// remove
+		collection.Schema.RemoveField("0kahthzr")
+
+		return dao.SaveCollection(collection)
+	})
+}

backend/model/eventModel.go

@@ -5,7 +5,7 @@ import "github.com/pocketbase/pocketbase/models"
 type Events []*Event
 
 type Event struct {
-	UUID      string `db:"UUID" json:"uuid"`
+	UUID      string `db:"uuid" json:"uuid"`
 	Day       string `db:"Day" json:"day"`
 	Week      string `db:"Week" json:"week"`
 	Start     string `db:"Start" json:"start"`
@@ -24,3 +24,9 @@ type Event struct {
 func (m *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
+}

backend/service/db/dbEvents.go

@@ -6,51 +6,59 @@ import (
 	"htwkalender/model"
 )
 
-func SaveEvents(seminarGroup []model.SeminarGroup, app *pocketbase.PocketBase) (model.Events, error) {
-	var toBeSavedEvents []struct {
-		model.Event
-		string
-	}
-	var savedRecords model.Events
+func SaveEvents(seminarGroup []model.SeminarGroup, app *pocketbase.PocketBase) ([]model.Event, error) {
+	var toBeSavedEvents []model.Event
+	var savedRecords []model.Event
 	// check if event is already in database and add to toBeSavedEvents if not
 	for _, seminarGroup := range seminarGroup {
 		for _, event := range seminarGroup.Events {
+			event = event.SetCourse(seminarGroup.Course)
 			dbGroup, err := findEventByDayWeekStartEndNameCourse(event, seminarGroup.Course, app)
 
-			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 {
-				return nil, err
+			if dbGroup.UUID != "" && err.Error() == "sql: no rows in result set" && !containsEvent(toBeSavedEvents, event) {
+				toBeSavedEvents = append(toBeSavedEvents, event)
 			}
 		}
 	}
 
 	// create record for each event that's not already in the database
 	for _, event := range toBeSavedEvents {
-
+		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.Event)
+			savedRecords = append(savedRecords, event)
 		}
 	}
 
 	return savedRecords, nil
 }
 
+func containsEvent(events []model.Event, event model.Event) bool {
+	for _, e := range events {
+		if 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 {
+			return true
+		}
+	}
+	return false
+
+}
+
 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)
-	if err != nil {
-		return nil, err
-	}
 	return &event, err
 }
 

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"
@@ -97,6 +98,7 @@ func parseSeminarGroup(result string) model.SeminarGroup {
 	semesterString := findFirstSpanWithClass(table, "header-0-2-0").FirstChild.Data
 	semester, year := extractSemesterAndYear(semesterString)
 	events = convertWeeksToDates(events, semester, year)
+	events = generateUUIDs(events)
 	var seminarGroup = model.SeminarGroup{
 		University: findFirstSpanWithClass(table, "header-1-0-0").FirstChild.Data,
 		Course:     findFirstSpanWithClass(table, "header-2-0-1").FirstChild.Data,
@@ -105,6 +107,16 @@ func parseSeminarGroup(result string) model.SeminarGroup {
 	return seminarGroup
 }
 
+func generateUUIDs(events []model.Event) []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+event.Course+event.Semester))
+		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)