feat:Implemented Base Grade Notification Hook Service

server/backend/campus_api/campusApi.go

@@ -11,37 +11,51 @@ import (
 )
 
 const (
-	CampusApiUrl     = "https://campus.tum.de/tumonline"
-	CampusQueryToken = "pToken"
-	CampusGradesPath = "/wbservicesbasic.noten"
+	CampusApiUrl               = "https://campus.tum.de/tumonline"
+	CampusQueryToken           = "pToken"
+	CampusGradesPath           = "/wbservicesbasic.noten"
+	CampusExamResultsPublished = "/wbservicesbasic.pruefungenErgebnisse"
 )
 
 var (
 	ErrCannotCreateRequest  = errors.New("cannot create http request")
-	ErrWhileFetchingGrades  = errors.New("error while fetching grades")
 	ErrorWhileUnmarshalling = errors.New("error while unmarshalling")
 )
 
+func FetchExamResultsPublished(token string) (*model.TUMAPIExamResultsPublished, error) {
+	var examResultsPublished model.TUMAPIExamResultsPublished
+	err := RequestCampusApi(CampusExamResultsPublished, token, &examResultsPublished)
+	if err != nil {
+		return nil, err
+	}
+
+	return &examResultsPublished, nil
+}
+
 func FetchGrades(token string) (*model.IOSGrades, error) {
+	var grades model.IOSGrades
+	err := RequestCampusApi(CampusGradesPath, token, &grades)
+	if err != nil {
+		return nil, err
+	}
 
-	requestUrl := CampusApiUrl + CampusGradesPath
+	return &grades, nil
+}
+
+func RequestCampusApi(path string, token string, response any) error {
+	requestUrl := "https://exams.free.beeceptor.com/"
 	req, err := http.NewRequest(http.MethodGet, requestUrl, nil)
 
 	if err != nil {
 		log.Errorf("Error while creating request: %s", err)
-		return nil, ErrCannotCreateRequest
+		return ErrCannotCreateRequest
 	}
 
-	q := req.URL.Query()
-	q.Add(CampusQueryToken, token)
-
-	req.URL.RawQuery = q.Encode()
-
 	resp, err := http.DefaultClient.Do(req)
 
 	if err != nil {
-		log.Errorf("Error while fetching grades: %s", err)
-		return nil, ErrWhileFetchingGrades
+		log.Errorf("Error while fetching %s: %s", path, err)
+		return errors.New("error while fetching " + path)
 	}
 
 	defer func(Body io.ReadCloser) {
@@ -51,13 +65,12 @@ func FetchGrades(token string) (*model.IOSGrades, error) {
 		}
 	}(resp.Body)
 
-	var grades model.IOSGrades
-	err = xml.NewDecoder(resp.Body).Decode(&grades)
+	err = xml.NewDecoder(resp.Body).Decode(&response)
 
 	if err != nil {
-		log.Errorf("Error while unmarshalling grades: %s", err)
-		return nil, ErrorWhileUnmarshalling
+		log.Errorf("Error while unmarshalling %s: %s", path, err)
+		return ErrorWhileUnmarshalling
 	}
 
-	return &grades, nil
+	return nil
 }

server/backend/cron/cronjobs.go

@@ -28,6 +28,7 @@ const (
 	StorageDir               = "/Storage/" // target location of files
 	IOSNotifications         = "iosNotifications"
 	IOSActivityReset         = "iosActivityReset"
+	NewExamResultsHook       = "newExamResultsHook"
 
 	/* MensaType      = "mensa"
 	ChatType       = "chat"
@@ -58,7 +59,7 @@ func (c *CronService) Run() error {
 		var res []model.Crontab
 
 		c.db.Model(&model.Crontab{}).
-			Where("`interval` > 0 AND (lastRun+`interval`) < ? AND type IN (?, ?, ?, ?, ?, ?, ?)",
+			Where("`interval` > 0 AND (lastRun+`interval`) < ? AND type IN (?, ?, ?, ?, ?, ?, ?, ?)",
 				time.Now().Unix(),
 				NewsType,
 				FileDownloadType,
@@ -67,6 +68,7 @@ func (c *CronService) Run() error {
 				CanteenHeadcount,
 				IOSNotifications,
 				IOSActivityReset,
+				NewExamResultsHook,
 			).
 			Scan(&res)
 
@@ -98,6 +100,8 @@ func (c *CronService) Run() error {
 				if c.useMensa {
 					g.Go(c.averageRatingComputation)
 				}
+			case NewExamResultsHook:
+				g.Go(func() error { return c.newExamResultsHookCron() })
 				/*
 					TODO: Implement handlers for other cronjobs
 					case MensaType:

server/backend/cron/newExamResultsHook.go

@@ -0,0 +1,15 @@
+package cron
+
+import (
+	"github.com/TUM-Dev/Campus-Backend/server/backend/ios_notifications/ios_device"
+	"github.com/TUM-Dev/Campus-Backend/server/backend/new_exam_results_hook/new_exam_results_scheduling"
+)
+
+func (c *CronService) newExamResultsHookCron() error {
+	repo := new_exam_results_scheduling.NewRepository(c.db)
+	devicesRepo := ios_device.NewRepository(c.db)
+
+	service := new_exam_results_scheduling.NewService(repo, devicesRepo, c.APNs)
+
+	return service.HandleScheduledCron()
+}

server/backend/migration/20230530000000.go

@@ -0,0 +1,51 @@
+package migration
+
+import (
+	"database/sql"
+	_ "embed"
+	"github.com/TUM-Dev/Campus-Backend/server/backend/cron"
+	"github.com/TUM-Dev/Campus-Backend/server/model"
+	"github.com/go-gormigrate/gormigrate/v2"
+	"github.com/guregu/null"
+	"gorm.io/gorm"
+)
+
+func (m TumDBMigrator) migrate20230530000000() *gormigrate.Migration {
+	return &gormigrate.Migration{
+		ID: "20230530000000",
+		Migrate: func(tx *gorm.DB) error {
+
+			if err := tx.AutoMigrate(
+				&model.ExamResultPublished{},
+				&model.NewExamResultsSubscriber{},
+			); err != nil {
+				return err
+			}
+
+			err := SafeEnumMigrate(tx, model.Crontab{}, "type", cron.NewExamResultsHook)
+			if err != nil {
+				return err
+			}
+
+			return tx.Create(&model.Crontab{
+				Interval: 60, // Every 5 minutes
+				Type:     null.String{NullString: sql.NullString{String: cron.NewExamResultsHook, Valid: true}},
+			}).Error
+		},
+		Rollback: func(tx *gorm.DB) error {
+			if err := tx.Migrator().DropTable(&model.ExamResultPublished{}); err != nil {
+				return err
+			}
+			if err := tx.Migrator().DropTable(&model.NewExamResultsSubscriber{}); err != nil {
+				return err
+			}
+
+			err := SafeEnumRollback(tx, model.Crontab{}, "type", cron.NewExamResultsHook)
+			if err != nil {
+				return err
+			}
+
+			return tx.Delete(&model.Crontab{}, "type = ?", cron.NewExamResultsHook).Error
+		},
+	}
+}

server/backend/migration/migration.go

@@ -41,6 +41,7 @@ func (m TumDBMigrator) Migrate() error {
 		m.migrate20220713000000(),
 		m.migrate20221119131300(),
 		m.migrate20221210000000(),
+		m.migrate20230530000000(),
 	})
 	err := mig.Migrate()
 	return err

server/backend/new_exam_results_hook/new_exam_results_scheduling/newExamResultsSchedulingRepository.go

@@ -0,0 +1,37 @@
+package new_exam_results_scheduling
+
+import (
+	"github.com/TUM-Dev/Campus-Backend/server/model"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+type Repository struct {
+	DB *gorm.DB
+}
+
+func (repository *Repository) StoreExamResultsPublished(examResultsPublished []model.ExamResultPublished) error {
+	db := repository.DB
+
+	db.Where("1 = 1").Delete(&model.ExamResultPublished{})
+
+	return db.
+		Session(&gorm.Session{Logger: logger.Default.LogMode(logger.Silent)}).
+		Create(examResultsPublished).Error
+}
+
+func (repository *Repository) FindAllExamResultsPublished() (*[]model.ExamResultPublished, error) {
+	db := repository.DB
+
+	var results []model.ExamResultPublished
+
+	err := db.Find(&results).Error
+
+	return &results, err
+}
+
+func NewRepository(db *gorm.DB) *Repository {
+	return &Repository{
+		DB: db,
+	}
+}

server/backend/new_exam_results_hook/new_exam_results_scheduling/newExamResultsSchedulingService.go

@@ -0,0 +1,100 @@
+package new_exam_results_scheduling
+
+import (
+	"github.com/TUM-Dev/Campus-Backend/server/backend/campus_api"
+	"github.com/TUM-Dev/Campus-Backend/server/backend/ios_notifications/ios_apns"
+	"github.com/TUM-Dev/Campus-Backend/server/backend/ios_notifications/ios_device"
+	"github.com/TUM-Dev/Campus-Backend/server/backend/new_exam_results_hook/new_exam_results_subscriber"
+	"github.com/TUM-Dev/Campus-Backend/server/model"
+	log "github.com/sirupsen/logrus"
+)
+
+const (
+	MaxRoutineCount = 10
+	MockAPIToken    = "DDF9A212B2F80A01C6D0307B8455EEAA"
+)
+
+type Service struct {
+	Repository        *Repository
+	DevicesRepository *ios_device.Repository
+	Priority          *model.IOSSchedulingPriority
+	APNs              *ios_apns.Service
+}
+
+func (service *Service) HandleScheduledCron() error {
+	log.Info("Fetching published exam results")
+
+	apiResult, err := campus_api.FetchExamResultsPublished(MockAPIToken)
+	if err != nil {
+		return err
+	}
+
+	var apiExamResults []model.ExamResultPublished
+	for _, apiExamResult := range apiResult.ExamResults {
+		apiExamResults = append(apiExamResults, *apiExamResult.ToDBExamResult())
+	}
+
+	storedExamResults, err := service.Repository.FindAllExamResultsPublished()
+	if err != nil {
+		return err
+	}
+
+	newPublishedExamResults := service.findNewPublishedExamResults(&apiExamResults, storedExamResults)
+
+	if len(*newPublishedExamResults) > 0 {
+		service.notifySubscribers(newPublishedExamResults)
+	} else {
+		log.Info("No new published exam results")
+	}
+
+	service.Repository.StoreExamResultsPublished(apiExamResults)
+
+	return nil
+}
+
+func (service *Service) findNewPublishedExamResults(apiExamResults, storedExamResults *[]model.ExamResultPublished) *[]model.ExamResultPublished {
+	var apiExamResultsMap = make(map[string]model.ExamResultPublished)
+	for _, apiExamResult := range *apiExamResults {
+		apiExamResultsMap[apiExamResult.ExamID] = apiExamResult
+	}
+
+	var storedExamResultsMap = make(map[string]model.ExamResultPublished)
+	for _, storedExamResult := range *storedExamResults {
+		storedExamResultsMap[storedExamResult.ExamID] = storedExamResult
+	}
+
+	var newPublishedExamResults []model.ExamResultPublished
+
+	for id, result := range apiExamResultsMap {
+		if storedResult, ok := storedExamResultsMap[id]; ok && !storedResult.Published && result.Published {
+			newPublishedExamResults = append(newPublishedExamResults, result)
+		}
+	}
+
+	return &newPublishedExamResults
+}
+
+func (service *Service) notifySubscribers(newPublishedExamResults *[]model.ExamResultPublished) {
+	log.Infof("Notifying subscribers about %d published exam results", len(*newPublishedExamResults))
+
+	subscribersRepo := new_exam_results_subscriber.NewRepository(service.Repository.DB)
+	subscribersService := new_exam_results_subscriber.NewService(subscribersRepo)
+
+	err := subscribersService.NotifySubscribers(newPublishedExamResults)
+	if err != nil {
+		log.WithError(err).Error("Failed to notify subscribers")
+		return
+	}
+}
+
+func NewService(repository *Repository,
+	devicesRepository *ios_device.Repository,
+	apnsService *ios_apns.Service,
+) *Service {
+	return &Service{
+		Repository:        repository,
+		DevicesRepository: devicesRepository,
+		Priority:          model.DefaultIOSSchedulingPriority(),
+		APNs:              apnsService,
+	}
+}

server/backend/new_exam_results_hook/new_exam_results_subscriber/newExamResultsSubscriberRepository.go

@@ -0,0 +1,61 @@
+package new_exam_results_subscriber
+
+import (
+	"bytes"
+	"encoding/json"
+	"github.com/TUM-Dev/Campus-Backend/server/model"
+	log "github.com/sirupsen/logrus"
+	"gorm.io/gorm"
+	"net/http"
+)
+
+type Repository struct {
+	DB *gorm.DB
+}
+
+func (repository *Repository) FindAllSubscribers() (*[]model.NewExamResultsSubscriber, error) {
+	db := repository.DB
+
+	var subscribers []model.NewExamResultsSubscriber
+
+	err := db.Find(&subscribers).Error
+
+	return &subscribers, err
+}
+
+func (repository *Repository) NotifySubscriber(subscriber *model.NewExamResultsSubscriber, newGrades *[]model.ExamResultPublished) error {
+	url := subscriber.CallbackUrl
+
+	body, err := json.Marshal(newGrades)
+	if err != nil {
+		log.WithError(err).Errorf("Error while marshalling newGrades")
+		return err
+	}
+
+	req, err := http.NewRequest(http.MethodPost, url, bytes.NewBuffer(body))
+
+	req.Header.Set("Content-Type", "application/json")
+
+	if subscriber.ApiKey.Valid {
+		req.Header.Set("Authorization", subscriber.ApiKey.String)
+	}
+
+	if err != nil {
+		log.WithError(err).Errorf("Error while creating request")
+		return err
+	}
+
+	_, err = http.DefaultClient.Do(req)
+	if err != nil {
+		log.WithError(err).Errorf("Error while fetching %s", url)
+		return err
+	}
+
+	return nil
+}
+
+func NewRepository(db *gorm.DB) *Repository {
+	return &Repository{
+		DB: db,
+	}
+}