fix:#65 updated db model for proxyrecord

services/data-manager/service/db/dbEvents.go

@@ -29,47 +29,212 @@ import (
 	"github.com/pocketbase/pocketbase"
 )
 
-func SaveSeminarGroupEvents(seminarGroup model.SeminarGroup, app *pocketbase.PocketBase) ([]model.Event, error) {
-	var toBeSavedEvents model.Events
-	var savedRecords model.Events
+var _ core.RecordProxy = (*Event)(nil)
 
-	// check if event is already in database and add to toBeSavedEvents if not
-	for _, event := range seminarGroup.Events {
-		event = event.SetCourse(seminarGroup.Course)
-		existsInDatabase, err := findEventByDayWeekStartEndNameCourse(event, seminarGroup.Course, app)
-		alreadyAddedToSave := toBeSavedEvents.Contains(event)
-
-		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 {
-		event.MarkAsNew()
-		// auto mapping for event fields to record fields
-		err := app.Save(&event)
-		if err != nil {
-			return nil, err
-		} else {
-			savedRecords = append(savedRecords, event)
-		}
-	}
-
-	return savedRecords, nil
+type Event struct {
+	core.BaseRecordProxy
 }
 
-func SaveEvents(events []model.Event, base *pocketbase.PocketBase) ([]model.Event, error) {
+type Events []*Event
+
+func (event *Event) GetDay() string {
+	return event.GetString("Day")
+}
+
+func (event *Event) SetDay(day string) {
+	event.Set("Day", day)
+}
+
+func (event *Event) GetWeek() string {
+	return event.GetString("Week")
+}
+
+func (event *Event) SetWeek(week string) {
+	event.Set("Week", week)
+}
+
+func (event *Event) GetName() string {
+	return event.GetString("Name")
+}
+
+func (event *Event) SetName(name string) {
+	event.Set("Name", name)
+}
+
+func (event *Event) GetEventType() string {
+	return event.GetString("EventType")
+}
+
+func (event *Event) SetEventType(eventType string) {
+	event.Set("EventType", eventType)
+}
+
+func (event *Event) GetProf() string {
+	return event.GetString("Prof")
+}
+
+func (event *Event) SetProf(prof string) {
+	event.Set("Prof", prof)
+}
+
+func (event *Event) GetRooms() string {
+	return event.GetString("Rooms")
+}
+
+func (event *Event) SetRooms(rooms string) {
+	event.Set("Rooms", rooms)
+}
+
+func (event *Event) GetNotes() string {
+	return event.GetString("Notes")
+}
+
+func (event *Event) SetNotes(notes string) {
+	event.Set("Notes", notes)
+}
+
+func (event *Event) GetBookedAt() string {
+	return event.GetString("BookedAt")
+}
+
+func (event *Event) SetBookedAt(bookedAt string) {
+	event.Set("BookedAt", bookedAt)
+}
+
+func (event *Event) GetCourse() string {
+	return event.GetString("course")
+}
+
+func (event *Event) SetCourse(course string) {
+	event.Set("course", course)
+}
+
+func (event *Event) GetSemester() string {
+	return event.GetString("semester")
+}
+
+func (event *Event) SetSemester(semester string) {
+	event.Set("semester", semester)
+}
+
+func (event *Event) GetUUID() string {
+	return event.GetString("uuid")
+}
+
+func (event *Event) SetUUID(uuid string) {
+	event.Set("uuid", uuid)
+}
+
+func (event *Event) GetStart() types.DateTime {
+	return event.GetDateTime("start")
+}
+
+func (event *Event) SetStart(start types.DateTime) {
+	event.Set("start", start)
+}
+
+func (event *Event) GetEnd() types.DateTime {
+	return event.GetDateTime("end")
+}
+
+func (event *Event) SetEnd(end types.DateTime) {
+	event.Set("end", end)
+}
+
+func (event *Event) GetCompulsory() string {
+	return event.GetString("Compulsory")
+}
+
+func (event *Event) SetCompulsory(compulsory string) {
+	event.Set("Compulsory", compulsory)
+}
+
+func (event *Event) GetCreated() types.DateTime {
+	return event.GetDateTime("created")
+}
+
+func (event *Event) SetCreated(created types.DateTime) {
+	event.Set("created", created)
+}
+
+func (event *Event) GetUpdated() types.DateTime {
+	return event.GetDateTime("updated")
+}
+
+func (event *Event) SetUpdated(updated types.DateTime) {
+	event.Set("updated", updated)
+}
+
+func newEvent(record *core.Record) *Event {
+	return &Event{
+		BaseRecordProxy: core.BaseRecordProxy{Record: record},
+	}
+}
+
+func NewEvent(collection *core.Collection, event model.Event) (*Event, error) {
+	// Create a new Event instance
+	if collection.Name != "events" {
+		return nil, core.ErrInvalidFieldValue
+	}
+
+	record := core.NewRecord(collection)
+	record.Set("id:autogenerate", "")
+
+	ev := newEvent(record)
+	// Set the fields from the model
+	ev.SetDay(event.Day)
+	ev.SetWeek(event.Week)
+	ev.SetStart(event.Start)
+	ev.SetEnd(event.End)
+	ev.SetName(event.Name)
+	ev.SetEventType(event.EventType)
+	ev.SetProf(event.Prof)
+	ev.SetRooms(event.Rooms)
+	ev.SetNotes(event.Notes)
+	ev.SetBookedAt(event.BookedAt)
+	ev.SetCourse(event.Course)
+	ev.SetSemester(event.Semester)
+	ev.SetUUID(uuid.NewString())
+	return ev, nil
+}
+
+func (event *Event) ToModel() model.Event {
+	return model.Event{
+		Day:       event.GetDay(),
+		Week:      event.GetWeek(),
+		Start:     event.GetStart(),
+		End:       event.GetEnd(),
+		Name:      event.GetName(),
+		EventType: event.GetEventType(),
+		Prof:      event.GetProf(),
+		Rooms:     event.GetRooms(),
+		Notes:     event.GetNotes(),
+		BookedAt:  event.GetBookedAt(),
+		Course:    event.GetCourse(),
+		Semester:  event.GetSemester(),
+		UUID:      event.GetUUID(),
+	}
+}
+
+func (events *Events) ToEvents() model.Events {
+	var result model.Events
+	for _, event := range *events {
+		result = append(result, event.ToModel())
+	}
+	return result
+}
+
+func SaveSeminarGroupEvents(seminarGroup model.SeminarGroup, base *pocketbase.PocketBase) (model.Events, error) {
+	return SaveEvents(seminarGroup.Events, base.App)
+}
+
+func SaveEvents(events []model.Event, app core.App) (model.Events, error) {
 	var toBeSavedEvents model.Events
 	var savedRecords model.Events
 
 	// check if event is already in database and add to toBeSavedEvents if not
 	for _, event := range events {
-		existsInDatabase, err := findEventByDayWeekStartEndNameCourse(event, event.Course, base)
+		existsInDatabase, err := findEventByDayWeekStartEndNameCourse(event, event.Course, app)
 		alreadyAddedToSave := toBeSavedEvents.Contains(event)
 
 		if err != nil {
@@ -80,26 +245,45 @@ func SaveEvents(events []model.Event, base *pocketbase.PocketBase) ([]model.Even
 			toBeSavedEvents = append(toBeSavedEvents, event)
 		}
 	}
+
+	collection, err := app.FindCollectionByNameOrId("events")
+	if err != nil {
+		return nil, err
+	}
+
 	// 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 := base.Save(&event)
-		if err != nil {
-			return nil, err
+		savedEvent, saveErr := saveEvent(collection, event, app)
+		if saveErr != nil {
+			return nil, saveErr
 		} else {
-			savedRecords = append(savedRecords, event)
+			savedRecords = append(savedRecords, savedEvent.ToModel())
 		}
 	}
 	return savedRecords, nil
 }
 
+func saveEvent(collection *core.Collection, event model.Event, app core.App) (*Event, error) {
+	dbEvent, recordErr := NewEvent(collection, event)
+	if recordErr != nil {
+		return nil, recordErr
+	}
+	// auto mapping for event fields to record fields
+	dbErr := app.Save(dbEvent)
+	if dbErr != nil {
+		return nil, dbErr
+	}
+
+	return dbEvent, nil
+}
+
 // 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, base *pocketbase.PocketBase) (bool, error) {
+func findEventByDayWeekStartEndNameCourse(event model.Event, course string, app core.App) (bool, error) {
 
 	var dbEvent model.Event
 
-	err := base.DB().Select("*").From("events").
+	err := app.DB().Select("*").From("events").
 		Where(dbx.NewExp(
 			"Day = {:day} AND "+
 				"Week = {:week} AND "+