840 short description for each video

api/courses.go

@@ -344,7 +344,14 @@ func (r coursesRoutes) getCourseBySlug(c *gin.Context) {
 		Streams []model.StreamDTO
 	}
 
-	course, err := r.CoursesDao.GetCourseBySlugYearAndTerm(c, uri.Slug, query.Term, query.Year)
+	user := tumLiveContext.User
+	var course model.Course
+	var err error
+	if user == nil {
+		course, err = r.CoursesDao.GetCourseBySlugYearAndTerm(c, uri.Slug, query.Term, query.Year)
+	} else {
+		course, err = r.CoursesDao.GetCourseBySlugYearTermUser(c, uri.Slug, query.Term, query.Year, user.ID)
+	}
 	if err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			_ = c.Error(tools.RequestError{
@@ -367,7 +374,6 @@ func (r coursesRoutes) getCourseBySlug(c *gin.Context) {
 		return
 	}
 
-	user := tumLiveContext.User
 	var streams []model.Stream
 	for _, stream := range course.Streams {
 		if !stream.Private || (user != nil && user.IsAdminOfCourse(course)) {

api/courses_test.go

@@ -367,7 +367,7 @@ func TestCoursesCRUD(t *testing.T) {
 							mock := mock_dao.NewMockCoursesDao(gomock.NewController(t))
 							mock.
 								EXPECT().
-								GetCourseBySlugYearAndTerm(gomock.Any(), testutils.CourseTensNet.Slug, "S", 2023).
+								GetCourseBySlugYearTermUser(gomock.Any(), testutils.CourseTensNet.Slug, "S", 2023, testutils.TUMLiveContextStudent.User.ID).
 								Return(model.Course{}, gorm.ErrRecordNotFound).
 								AnyTimes()
 							return mock
@@ -385,7 +385,7 @@ func TestCoursesCRUD(t *testing.T) {
 							mock := mock_dao.NewMockCoursesDao(gomock.NewController(t))
 							mock.
 								EXPECT().
-								GetCourseBySlugYearAndTerm(gomock.Any(), testutils.CourseTensNet.Slug, "S", 2023).
+								GetCourseBySlugYearTermUser(gomock.Any(), testutils.CourseTensNet.Slug, "S", 2023, testutils.TUMLiveContextStudent.User.ID).
 								Return(model.Course{}, errors.New("")).
 								AnyTimes()
 							return mock
@@ -403,7 +403,7 @@ func TestCoursesCRUD(t *testing.T) {
 							mock := mock_dao.NewMockCoursesDao(gomock.NewController(t))
 							mock.
 								EXPECT().
-								GetCourseBySlugYearAndTerm(gomock.Any(), testutils.CourseTensNet.Slug, "S", 2023).
+								GetCourseBySlugYearTermUser(gomock.Any(), testutils.CourseTensNet.Slug, "S", 2023, testutils.TUMLiveContextAdmin.User.ID).
 								Return(testutils.CourseTensNet, nil).
 								AnyTimes()
 							return mock
@@ -442,7 +442,7 @@ func TestCoursesCRUD(t *testing.T) {
 								AnyTimes()
 							coursesMock.
 								EXPECT().
-								GetCourseBySlugYearAndTerm(gomock.Any(), testutils.CourseFPV.Slug, testutils.CourseFPV.TeachingTerm, testutils.CourseFPV.Year).
+								GetCourseBySlugYearTermUser(gomock.Any(), testutils.CourseFPV.Slug, testutils.CourseFPV.TeachingTerm, testutils.CourseFPV.Year, testutils.TUMLiveContextStudent.User.ID).
 								Return(testutils.CourseFPV, nil).
 								AnyTimes()
 							return coursesMock
@@ -468,7 +468,7 @@ func TestCoursesCRUD(t *testing.T) {
 								AnyTimes()
 							coursesMock.
 								EXPECT().
-								GetCourseBySlugYearAndTerm(gomock.Any(), testutils.CourseFPV.Slug, testutils.CourseFPV.TeachingTerm, testutils.CourseFPV.Year).
+								GetCourseBySlugYearTermUser(gomock.Any(), testutils.CourseFPV.Slug, testutils.CourseFPV.TeachingTerm, testutils.CourseFPV.Year, testutils.TUMLiveContextAdmin.User.ID).
 								Return(testutils.CourseFPV, nil).
 								AnyTimes()
 							coursesMock.

api/stream.go

@@ -45,6 +45,11 @@ func configGinStreamRestRouter(router *gin.Engine, daoWrapper dao.DaoWrapper) {
 
 			streamById.GET("/playlist", routes.getStreamPlaylist)
 
+			withUser := streamById.Use(tools.LoggedIn)
+			{
+				withUser.PUT("/personalLectureName", routes.changePersonalLectureName)
+			}
+
 			thumbs := streamById.Group("/thumbs")
 			{
 				thumbs.GET(":fid", routes.getThumbs)
@@ -894,3 +899,63 @@ func (r streamRoutes) updateChatEnabled(c *gin.Context) {
 		return
 	}
 }
+
+type changePersonalLectureNameRequest struct {
+	PersonalLectureName string `json:"personalLectureName"`
+}
+
+func (r streamRoutes) changePersonalLectureName(c *gin.Context) {
+	ctx := c.MustGet("TUMLiveContext").(tools.TUMLiveContext)
+
+	streamIdAsString := c.Param("streamID")
+	streamId, err := strconv.ParseUint(streamIdAsString, 10, 32)
+	if err != nil {
+		logger.Error("can not parse stream id in request url", "err", err)
+		_ = c.Error(tools.RequestError{
+			Status:        http.StatusBadRequest,
+			CustomMessage: "can not parse stream id in request url",
+			Err:           err,
+		})
+		return
+	}
+
+	var update changePersonalLectureNameRequest
+	err = c.BindJSON(&update)
+	if err != nil {
+		logger.Error("failed to bind personal lecture name JSON", "err", err)
+		_ = c.Error(tools.RequestError{
+			Status:        http.StatusBadRequest,
+			CustomMessage: "can not bind body",
+			Err:           err,
+		})
+		return
+	}
+
+	if update.PersonalLectureName == "" {
+		err = r.UserDefinedLectureTitlesDao.Delete(ctx.User.ID, uint(streamId))
+		if err != nil {
+			logger.Error("failed to delete personal lecture name", "err", err)
+			_ = c.Error(tools.RequestError{
+				Status:        http.StatusInternalServerError,
+				CustomMessage: "can not delete personal lecture name",
+				Err:           err,
+			})
+		}
+		return
+	}
+
+	err = r.UserDefinedLectureTitlesDao.Upsert(&model.UserDefinedLectureTitle{
+		UserID:   ctx.User.ID,
+		StreamID: uint(streamId),
+		Title:    update.PersonalLectureName,
+	})
+	if err != nil {
+		logger.Error("failed to upsert personal lecture name", "err", err)
+		_ = c.Error(tools.RequestError{
+			Status:        http.StatusInternalServerError,
+			CustomMessage: "can not upsert personal lecture name",
+			Err:           err,
+		})
+		return
+	}
+}

cmd/tumlive/tumlive.go

@@ -212,6 +212,7 @@ func main() {
 		&model.TranscodingFailure{},
 		&model.Email{},
 		&model.Runner{},
+		&model.UserDefinedLectureTitle{},
 	)
 	if err != nil {
 		sentry.CaptureException(err)

dao/courses.go

@@ -30,6 +30,7 @@ type CoursesDao interface {
 	GetCourseById(ctx context.Context, id uint) (course model.Course, err error)
 	GetInvitedUsersForCourse(course *model.Course) error
 	GetCourseBySlugYearAndTerm(ctx context.Context, slug string, term string, year int) (model.Course, error)
+	GetCourseBySlugYearTermUser(ctx context.Context, slug string, term string, year int, userID uint) (model.Course, error)
 	// GetAllCoursesWithTUMIDFromSemester returns all courses with a non-null tum_identifier from a given semester or later
 	GetAllCoursesWithTUMIDFromSemester(ctx context.Context, year int, term string) (courses []model.Course, err error)
 	GetAvailableSemesters(c context.Context, includeTestSemester bool) []model.Semester
@@ -231,6 +232,25 @@ func (d coursesDao) GetCourseBySlugYearAndTerm(ctx context.Context, slug string,
 	return course, err
 }
 
+// GetCourseBySlugYearTermUser loads courses with streams preloaded. Difference to GetCourseBySlugYearAndTerm: personal lecture titles of user are loaded as well
+func (d coursesDao) GetCourseBySlugYearTermUser(ctx context.Context, slug string, term string, year int, userID uint) (model.Course, error) {
+	cachedCourses, found := Cache.Get(fmt.Sprintf("courseBySlugYearTermUser%v%v%v%v", slug, term, year, userID))
+	if found {
+		return cachedCourses.(model.Course), nil
+	}
+	var course model.Course
+	err := DB.Preload("Streams.VideoSections").Preload("Streams.Units", func(db *gorm.DB) *gorm.DB {
+		return db.Order("unit_start desc")
+	}).Preload("Streams", func(db *gorm.DB) *gorm.DB {
+		return db.Order("start desc")
+	}).Preload("Streams.CustomLectureTitles", "user_id = ?", userID).
+		Preload("Admins").Where("teaching_term = ? AND slug = ? AND year = ?", term, slug, year).First(&course).Error
+	if err == nil {
+		Cache.SetWithTTL(fmt.Sprintf("courseBySlugYearTermUser%v%v%v%v", slug, term, year, userID), course, 1, time.Minute)
+	}
+	return course, err
+}
+
 func (d coursesDao) GetAllCoursesWithTUMIDFromSemester(ctx context.Context, year int, term string) (courses []model.Course, err error) {
 	var foundCourses []model.Course
 

dao/dao_base.go

@@ -37,33 +37,35 @@ type DaoWrapper struct {
 	TranscodingFailureDao
 	EmailDao
 	RunnerDao RunnerDao
+	UserDefinedLectureTitlesDao
 }
 
 func NewDaoWrapper() DaoWrapper {
 	return DaoWrapper{
-		CameraPresetDao:       NewCameraPresetDao(),
-		ChatDao:               NewChatDao(),
-		FileDao:               NewFileDao(),
-		StreamsDao:            NewStreamsDao(),
-		CoursesDao:            NewCoursesDao(),
-		WorkerDao:             NewWorkerDao(),
-		LectureHallsDao:       NewLectureHallsDao(),
-		UsersDao:              NewUsersDao(),
-		UploadKeyDao:          NewUploadKeyDao(),
-		StatisticsDao:         NewStatisticsDao(),
-		ProgressDao:           NewProgressDao(),
-		ServerNotificationDao: NewServerNotificationDao(),
-		TokenDao:              NewTokenDao(),
-		NotificationsDao:      NewNotificiationsDao(),
-		IngestServerDao:       NewIngestServerDao(),
-		VideoSectionDao:       NewVideoSectionDao(),
-		InfoPageDao:           NewInfoPageDao(),
-		VideoSeekDao:          NewVideoSeekDao(),
-		AuditDao:              NewAuditDao(),
-		BookmarkDao:           NewBookmarkDao(),
-		SubtitlesDao:          NewSubtitlesDao(),
-		TranscodingFailureDao: NewTranscodingFailureDao(),
-		EmailDao:              NewEmailDao(),
-		RunnerDao:             NewRunnerDao(),
+		CameraPresetDao:             NewCameraPresetDao(),
+		ChatDao:                     NewChatDao(),
+		FileDao:                     NewFileDao(),
+		StreamsDao:                  NewStreamsDao(),
+		CoursesDao:                  NewCoursesDao(),
+		WorkerDao:                   NewWorkerDao(),
+		LectureHallsDao:             NewLectureHallsDao(),
+		UsersDao:                    NewUsersDao(),
+		UploadKeyDao:                NewUploadKeyDao(),
+		StatisticsDao:               NewStatisticsDao(),
+		ProgressDao:                 NewProgressDao(),
+		ServerNotificationDao:       NewServerNotificationDao(),
+		TokenDao:                    NewTokenDao(),
+		NotificationsDao:            NewNotificiationsDao(),
+		IngestServerDao:             NewIngestServerDao(),
+		VideoSectionDao:             NewVideoSectionDao(),
+		InfoPageDao:                 NewInfoPageDao(),
+		VideoSeekDao:                NewVideoSeekDao(),
+		AuditDao:                    NewAuditDao(),
+		BookmarkDao:                 NewBookmarkDao(),
+		SubtitlesDao:                NewSubtitlesDao(),
+		TranscodingFailureDao:       NewTranscodingFailureDao(),
+		EmailDao:                    NewEmailDao(),
+		RunnerDao:                   NewRunnerDao(),
+		UserDefinedLectureTitlesDao: NewUserDefinedLectureTitlesDao(),
 	}
 }

dao/user_defined_lecture_titles.go

@@ -0,0 +1,50 @@
+package dao
+
+import (
+	"github.com/TUM-Dev/gocast/model"
+	"gorm.io/gorm"
+)
+
+//go:generate mockgen -source=user_defined_lecture_titles.go -destination ../mock_dao/user_defined_lecture_titles.go
+
+type UserDefinedLectureTitlesDao interface {
+	// Get UserDefinedLectureTitle by ID
+	Get(uint, uint) (model.UserDefinedLectureTitle, error)
+
+	// Create a new UserDefinedLectureTitle for the database
+	Create(*model.UserDefinedLectureTitle) error
+
+	// Delete a UserDefinedLectureTitle by user and stream id.
+	Delete(uint, uint) error
+
+	// Upsert updates the entry if it exists, inserts it else
+	Upsert(userLectureTitle *model.UserDefinedLectureTitle) error
+}
+
+type userDefinedLectureTitlesDao struct {
+	db *gorm.DB
+}
+
+func NewUserDefinedLectureTitlesDao() UserDefinedLectureTitlesDao {
+	return userDefinedLectureTitlesDao{db: DB}
+}
+
+// Get a userDefinedLectureTitlesDao by userID and streamID
+func (d userDefinedLectureTitlesDao) Get(userID uint, streamID uint) (res model.UserDefinedLectureTitle, err error) {
+	return res, d.db.First(&res, "user_id = ? AND stream_id = ?", userID, streamID).Error
+}
+
+// Create a userDefinedLectureTitlesDao.
+func (d userDefinedLectureTitlesDao) Create(it *model.UserDefinedLectureTitle) error {
+	return d.db.Create(it).Error
+}
+
+// Delete a userDefinedLectureTitlesDao by id.
+func (d userDefinedLectureTitlesDao) Delete(userID uint, streamID uint) error {
+	return d.db.Delete(&model.UserDefinedLectureTitle{}, "user_id = ? AND stream_id = ?", userID, streamID).Error
+}
+
+// Upsert updates the entry if it exists, inserts it else
+func (d userDefinedLectureTitlesDao) Upsert(userLectureTitle *model.UserDefinedLectureTitle) error {
+	return d.db.Save(userLectureTitle).Error
+}