feat:#39 added module and prof fetch

backend/service/fetch/v3/fetchLunaApi.go

@@ -2,16 +2,15 @@ package v3
 
 import (
 	"github.com/pocketbase/pocketbase"
-	"github.com/pocketbase/pocketbase/models"
+	"github.com/pocketbase/pocketbase/tools/types"
 	"golang.org/x/net/http2"
 	"htwkalender/model"
-	"htwkalender/service/db"
 	"log/slog"
 	"net/http"
 	"strconv"
 )
 
-func FetchAllResources(app *pocketbase.PocketBase) ([]*models.Record, error) {
+func FetchAllResources(app *pocketbase.PocketBase) (*[]model.Event, error) {
 	var groups []model.SeminarGroup
 	client := &http.Client{}
 	client.Transport = &http2.Transport{}
@@ -21,7 +20,7 @@ func FetchAllResources(app *pocketbase.PocketBase) ([]*models.Record, error) {
 	seminarUrl := apiUrl + "studierendengruppen"
 
 	parsedSeminarGroups, err := parseSeminarGroups(seminarUrl, client)
-
+	slog.Info("Fetched seminar groups: " + strconv.Itoa(len(parsedSeminarGroups.Groups)) + " of " + strconv.Itoa(parsedSeminarGroups.TotalItems))
 	if err != nil {
 		slog.Error("Error while fetching seminar groups", err)
 		return nil, err
@@ -30,7 +29,7 @@ func FetchAllResources(app *pocketbase.PocketBase) ([]*models.Record, error) {
 	studyTypeUrl := apiUrl + "studiengaenge"
 
 	parsedStudyTypes, err := parseStudyTypes(studyTypeUrl, client)
-
+	slog.Info("Fetched study types: " + strconv.Itoa(len(parsedStudyTypes)))
 	if err != nil {
 		slog.Error("Error while fetching study types", err)
 		return nil, err
@@ -38,15 +37,31 @@ func FetchAllResources(app *pocketbase.PocketBase) ([]*models.Record, error) {
 
 	facultyUrl := apiUrl + "fakultaeten"
 	parsedFaculties, err := parseFaculties(facultyUrl, client)
-
+	slog.Info("Fetched faculties: " + strconv.Itoa(len(parsedFaculties.Faculties)))
 	if err != nil {
 		slog.Error("Error while fetching faculties", err)
 		return nil, err
 	}
 
-	slog.Info("Fetched study types: " + strconv.Itoa(len(parsedStudyTypes)))
-	slog.Info("Fetched seminar groups: " + strconv.Itoa(len(parsedSeminarGroups.Groups)) + " of " + strconv.Itoa(parsedSeminarGroups.TotalItems))
-	slog.Info("Fetched faculties: " + strconv.Itoa(len(parsedFaculties.Faculties)))
+	moduleUrl := apiUrl + "module"
+	parsedModules, err := parseModules(moduleUrl, client)
+	slog.Info("Fetched modules: " + strconv.Itoa(len(parsedModules.Modules)))
+	if err != nil {
+		slog.Error("Error while fetching modules", err)
+		return nil, err
+	}
+
+	roomUrl := apiUrl + "raeume"
+	parsedRooms, err := parseRooms(roomUrl, client)
+	slog.Info("Fetched rooms: " + strconv.Itoa(len(parsedRooms.Rooms)))
+	if err != nil {
+		slog.Error("Error while fetching rooms", err)
+		return nil, err
+	}
+
+	profUrl := apiUrl + "dozierende"
+	parsedProfs, err := parseProfs(profUrl, client)
+	slog.Info("Fetched profs: " + strconv.Itoa(len(parsedProfs.Professors)))
 
 	// map seminar groups to model seminar groups
 	for _, group := range parsedSeminarGroups.Groups {
@@ -76,30 +91,106 @@ func FetchAllResources(app *pocketbase.PocketBase) ([]*models.Record, error) {
 		groups = append(groups, newGroup)
 	}
 
-	collection, dbError := db.FindCollection(app, "groups")
-	if dbError != nil {
-		slog.Error("Error while searching collection groups", dbError)
-		return nil, err
-	}
-	var insertedGroups []*models.Record
-
-	insertedGroups, dbError = db.SaveGroups(groups, collection, app)
-	if dbError != nil {
-		slog.Error("Error while saving groups", dbError)
-		return nil, err
-	}
-
 	//Now fetch all events
-
 	eventUrl := apiUrl + "veranstaltungen"
 	parsedEvents, err := parseEvents(eventUrl, client)
+	slog.Info("Fetched events: " + strconv.Itoa(len(parsedEvents.Events)) + " of " + strconv.Itoa(parsedEvents.TotalItems))
 
 	if err != nil {
 		slog.Error("Error while fetching events", err)
 		return nil, err
 	}
 
-	slog.Info("Fetched events: " + strconv.Itoa(len(parsedEvents.Events)) + " of " + strconv.Itoa(parsedEvents.TotalItems))
+	//resolve course id in parsedEvents to course name
+	for i, event := range parsedEvents.Events {
+		for j, course := range event.Courses {
+			for _, group := range parsedStudyTypes {
+				if group.ID == course {
+					parsedEvents.Events[i].Courses[j] = group.GroupID
+				}
+			}
+		}
 
-	return insertedGroups, nil
+		for _, group := range parsedSeminarGroups.Groups {
+			for courseItemId, seminarGroupItem := range event.SeminarGroups {
+				if group.ID == seminarGroupItem {
+					parsedEvents.Events[i].SeminarGroups[courseItemId] = group.SeminarGroup
+				}
+			}
+		}
+
+		for _, facultyItem := range parsedFaculties.Faculties {
+			if facultyItem.ID == event.Faculty {
+				parsedEvents.Events[i].Faculty = facultyItem.ShortCut
+			}
+		}
+
+		for _, module := range parsedModules.Modules {
+			if module.ID == event.Module {
+				parsedEvents.Events[i].Module = module.Name
+			}
+		}
+
+		for _, room := range parsedRooms.Rooms {
+			for roomPlace, roomID := range event.Rooms {
+				if room.ID == roomID {
+					parsedEvents.Events[i].Rooms[roomPlace] = room.ShortCut
+				}
+			}
+		}
+
+		for _, prof := range parsedProfs.Professors {
+			for profPlace, profID := range event.Professors {
+				if prof.ID == profID {
+					parsedEvents.Events[i].Professors[profPlace] = prof.Description1
+				}
+			}
+		}
+	}
+
+	// map events to model events
+	var events []model.Event
+
+	for _, event := range parsedEvents.Events {
+		for _, week := range event.CalendarWeeks {
+			for _, course := range event.Courses {
+				var newEvent model.Event
+				newEvent.UUID = ""
+				newEvent.Day = event.Day
+				newEvent.Week = strconv.Itoa(week)
+				newEvent.Start, _ = types.ParseDateTime(event.StartTime)
+				newEvent.End, _ = types.ParseDateTime(event.EndTime)
+				newEvent.Name = event.Module
+				newEvent.EventType = event.EventType
+				newEvent.Compulsory = ""
+				newEvent.Prof = concatStringArray(event.Professors, "|")
+				newEvent.Rooms = concatStringArray(event.Rooms, " ")
+				newEvent.Notes = event.Description
+				newEvent.BookedAt = event.BookedAt
+				newEvent.Course = course
+				newEvent.Semester = event.Semester
+				events = append(events, newEvent)
+			}
+		}
+	}
+
+	// return events
+	return &events, nil
+}
+
+func concatStringArray(array []string, concatChar string) string {
+	var result string
+
+	if len(array) == 0 {
+		return result
+	}
+
+	if len(array) > 1 {
+		for _, item := range array[:len(array)-1] {
+			result += item + concatChar
+		}
+	}
+	result += array[len(array)-1]
+
+	return result
 }