Tutorial groups: Introduce tutorial lectures

src/main/java/de/tum/cit/aet/artemis/communication/repository/conversation/ChannelRepository.java

@@ -66,11 +66,11 @@ public interface ChannelRepository extends ArtemisJpaRepository<Channel, Long> {
     @Query("""
             SELECT DISTINCT channel
             FROM Channel channel
-                LEFT JOIN channel.conversationParticipants cp
+                LEFT JOIN channel.conversationParticipants conversationParticipant
+                LEFT JOIN channel.lecture lecture
             WHERE channel.course.id = :courseId
-                AND (
-                   channel.isCourseWide = TRUE
-                   OR (channel.id = cp.conversation.id AND cp.user.id = :userId))
+                AND (channel.isCourseWide OR (channel.id = conversationParticipant.conversation.id AND conversationParticipant.user.id = :userId))
+                AND (lecture IS NULL OR NOT lecture.isTutorialLecture)
             ORDER BY channel.name
             """)
     List<Channel> findChannelsOfUser(@Param("courseId") Long courseId, @Param("userId") Long userId);

src/main/java/de/tum/cit/aet/artemis/core/repository/CourseRepository.java

@@ -127,7 +127,7 @@ SELECT COUNT(c) > 0
     Optional<Course> findWithEagerExercisesAndExerciseDetailsAndLecturesById(long courseId);
 
     @EntityGraph(type = LOAD, attributePaths = { "lectures", "lectures.lectureUnits", "lectures.attachments" })
-    Optional<Course> findWithEagerLecturesAndLectureUnitsById(long courseId);
+    Optional<Course> findWithLecturesAndLectureUnitsAndAttachmentsById(long courseId);
 
     @EntityGraph(type = LOAD, attributePaths = { "organizations", "competencies", "prerequisites", "tutorialGroupsConfiguration", "onlineCourseConfiguration" })
     Optional<Course> findForUpdateById(long courseId);
@@ -430,8 +430,8 @@ default Course findByIdWithLecturesElseThrow(long courseId) {
     }
 
     @NonNull
-    default Course findByIdWithLecturesAndLectureUnitsElseThrow(long courseId) {
-        return getValueElseThrow(findWithEagerLecturesAndLectureUnitsById(courseId), courseId);
+    default Course findWithLecturesAndLectureUnitsAndAttachmentsByIdElseThrow(long courseId) {
+        return getValueElseThrow(findWithLecturesAndLectureUnitsAndAttachmentsById(courseId), courseId);
     }
 
     @NonNull

src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisWebhookService.java

@@ -204,7 +204,7 @@ public String deleteLectureFromPyrisDB(List<AttachmentVideoUnit> attachmentVideo
      * @return jobToken if the job was created else null
      */
     public String addLectureUnitToPyrisDB(AttachmentVideoUnit attachmentVideoUnit) {
-        if (lectureIngestionEnabled(attachmentVideoUnit.getLecture().getCourse())) {
+        if (lectureIngestionEnabled(attachmentVideoUnit.getLecture().getCourse()) && !attachmentVideoUnit.getLecture().isTutorialLecture()) {
             if ((attachmentVideoUnit.getVideoSource() != null && !attachmentVideoUnit.getVideoSource().isEmpty()) || (attachmentVideoUnit.getAttachment() != null
                     && (attachmentVideoUnit.getAttachment().getAttachmentType() == AttachmentType.FILE && attachmentVideoUnit.getAttachment().getLink().endsWith(".pdf")))) {
                 return executeLectureAdditionWebhook(processAttachmentVideoUnitForUpdate(attachmentVideoUnit), attachmentVideoUnit.getLecture().getCourse());

src/main/java/de/tum/cit/aet/artemis/lecture/domain/Lecture.java

@@ -26,6 +26,7 @@
 
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonProperty;
 
 import de.tum.cit.aet.artemis.core.domain.Course;
 import de.tum.cit.aet.artemis.core.domain.DomainObject;
@@ -61,6 +62,9 @@ public class Lecture extends DomainObject {
     @Column(name = "visible_date")
     private ZonedDateTime visibleDate;
 
+    @Column(name = "is_tutorial_lecture")
+    private boolean isTutorialLecture;
+
     @OneToMany(mappedBy = "lecture", cascade = CascadeType.REMOVE, orphanRemoval = true)
     @JsonIgnoreProperties(value = "lecture", allowSetters = true)
     private Set<Attachment> attachments = new HashSet<>();
@@ -313,4 +317,13 @@ public boolean isVisibleToStudents() {
         }
         return visibleDate.isBefore(ZonedDateTime.now());
     }
+
+    @JsonProperty("isTutorialLecture")
+    public boolean isTutorialLecture() {
+        return isTutorialLecture;
+    }
+
+    public void setIsTutorialLecture(boolean isTutorialLecture) {
+        this.isTutorialLecture = isTutorialLecture;
+    }
 }

src/main/java/de/tum/cit/aet/artemis/lecture/repository/LectureRepository.java

@@ -36,13 +36,6 @@ public interface LectureRepository extends ArtemisJpaRepository<Lecture, Long> {
             """)
     Set<Lecture> findAllByCourseId(@Param("courseId") Long courseId);
 
-    @Query("""
-            SELECT lecture
-            FROM Lecture lecture
-            WHERE lecture.course.id = :courseId AND lecture.id IN :ids
-            """)
-    Set<Lecture> findAllByCourseIdWithIdIn(@Param("courseId") long courseId, @Param("ids") Set<Long> ids);
-
     @Query("""
             SELECT new de.tum.cit.aet.artemis.core.dto.calendar.LectureCalendarEventDTO(
                 lecture.id,
@@ -52,16 +45,15 @@ public interface LectureRepository extends ArtemisJpaRepository<Lecture, Long> {
                 lecture.endDate
             )
             FROM Lecture lecture
-            WHERE lecture.course.id = :courseId AND (lecture.startDate IS NOT NULL OR lecture.endDate IS NOT NULL)
+            WHERE lecture.course.id = :courseId AND (lecture.startDate IS NOT NULL OR lecture.endDate IS NOT NULL) AND NOT lecture.isTutorialLecture
             """)
     Set<LectureCalendarEventDTO> getLectureCalendarEventDTOsForCourseId(@Param("courseId") long courseId);
 
     @Query("""
             SELECT lecture
             FROM Lecture lecture
             LEFT JOIN FETCH lecture.lectureUnits
-            WHERE lecture.course.id = :courseId
-                AND (lecture.visibleDate IS NULL OR lecture.visibleDate <= :now)
+            WHERE lecture.course.id = :courseId AND (lecture.visibleDate IS NULL OR lecture.visibleDate <= :now)
             """)
     Set<Lecture> findAllVisibleByCourseIdWithEagerLectureUnits(@Param("courseId") long courseId, @Param("now") ZonedDateTime now);
 
@@ -81,6 +73,13 @@ public interface LectureRepository extends ArtemisJpaRepository<Lecture, Long> {
             """)
     Set<Lecture> findAllByCourseIdWithAttachments(@Param("courseId") Long courseId);
 
+    @Query("""
+            SELECT lecture
+            FROM Lecture lecture
+            WHERE lecture.course.id = :courseId AND lecture.isTutorialLecture
+            """)
+    Set<Lecture> findAllTutorialLecturesByCourseId(@Param("courseId") Long courseId);
+
     @Query("""
             SELECT lecture
             FROM Lecture lecture

src/main/java/de/tum/cit/aet/artemis/lecture/repository/LectureUnitMetricsRepository.java

@@ -29,10 +29,17 @@ public interface LectureUnitMetricsRepository extends ArtemisJpaRepository<Lectu
      * @return the lecture unit information for all lecture units in the course
      */
     @Query("""
-            SELECT new de.tum.cit.aet.artemis.atlas.dto.metrics.LectureUnitInformationDTO(lu.id, lu.lecture.id, lu.lecture.title, COALESCE(lu.name, a.name), lu.releaseDate, TYPE(lu))
-            FROM LectureUnit lu
-                LEFT JOIN Attachment a ON a.attachmentVideoUnit.id = lu.id
-            WHERE lu.lecture.course.id = :courseId
+            SELECT new de.tum.cit.aet.artemis.atlas.dto.metrics.LectureUnitInformationDTO(
+                lectureUnit.id,
+                lectureUnit.lecture.id,
+                lectureUnit.lecture.title,
+                COALESCE(lectureUnit.name, attachment.name),
+                lectureUnit.releaseDate,
+                TYPE(lectureUnit)
+            )
+            FROM LectureUnit lectureUnit
+                LEFT JOIN Attachment attachment ON attachment.attachmentVideoUnit.id = lectureUnit.id
+            WHERE lectureUnit.lecture.course.id = :courseId
             """)
     Set<LectureUnitInformationDTO> findAllLectureUnitInformationByCourseId(@Param("courseId") long courseId);
 

src/main/java/de/tum/cit/aet/artemis/lecture/web/LectureResource.java

@@ -234,6 +234,24 @@ public ResponseEntity<Set<Lecture>> getLecturesForCourse(@PathVariable Long cour
         return ResponseEntity.ok().body(lectures);
     }
 
+    /**
+     * GET /courses/:courseId/tutorial-lectures : get all the tutorial-lectures of a course
+     *
+     * @param courseId the courseId of the course for which the lectures should be returned
+     * @return the ResponseEntity with status 200 (OK) and the list of lectures in body
+     */
+    @GetMapping("courses/{courseId}/tutorial-lectures")
+    @EnforceAtLeastEditor
+    public ResponseEntity<Set<Lecture>> getTutorialLecturesForCourse(@PathVariable Long courseId) {
+        log.debug("REST request to get all Lectures for the course with id : {}", courseId);
+
+        Course course = courseRepository.findByIdElseThrow(courseId);
+        authCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.EDITOR, course, null);
+
+        Set<Lecture> lectures = lectureRepository.findAllTutorialLecturesByCourseId(courseId);
+        return ResponseEntity.ok().body(lectures);
+    }
+
     /**
      * GET /courses/:courseId/lectures : get all the lectures of a course with their lecture units and slides
      *
@@ -383,7 +401,7 @@ public ResponseEntity<Lecture> importLecture(@PathVariable long sourceLectureId,
     @PostMapping("courses/{courseId}/ingest")
     @EnforceAtLeastInstructorInCourse
     public ResponseEntity<Void> ingestLectures(@PathVariable Long courseId, @RequestParam(required = false) Optional<Long> lectureId) {
-        Course course = courseRepository.findByIdWithLecturesAndLectureUnitsElseThrow(courseId);
+        Course course = courseRepository.findWithLecturesAndLectureUnitsAndAttachmentsByIdElseThrow(courseId);
         authCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.INSTRUCTOR, course, null);
         if (lectureId.isPresent()) {
             Optional<Lecture> lectureToIngest = course.getLectures().stream().filter(lecture -> lecture.getId().equals(lectureId.get())).findFirst();

src/main/java/de/tum/cit/aet/artemis/lecture/web/LectureUnitResource.java

@@ -223,6 +223,9 @@ public ResponseEntity<Void> ingestLectureUnit(@PathVariable long lectureId, @Pat
         if (lectureUnit.getLecture().getId() != lectureId) {
             throw new BadRequestAlertException("Requested lecture unit is not part of the specified lecture", ENTITY_NAME, "lectureIdMismatch");
         }
+        if (lectureUnit.getLecture().isTutorialLecture()) {
+            throw new BadRequestAlertException("Units of tutorial lectures can not be ingested", ENTITY_NAME, "tutorialLectureIngestion");
+        }
         if (!(lectureUnit instanceof AttachmentVideoUnit)) {
             throw new BadRequestAlertException("Only attachment video units can be ingested into Pyris", ENTITY_NAME, "invalidLectureUnitType");
         }

src/main/resources/config/liquibase/changelog/20251024184500_changelog.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog https://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-latest.xsd">
+
+    <changeSet id="20251024184500-add-is-tutorial-lecture-column" author="marlonnienaber">
+        <addColumn tableName="lecture">
+            <column name="is_tutorial_lecture" type="boolean" defaultValueBoolean="false">
+                <constraints nullable="false"/>
+            </column>
+        </addColumn>
+
+        <rollback>
+            <dropColumn tableName="lecture" columnName="is_tutorial_lecture"/>
+        </rollback>
+    </changeSet>
+
+</databaseChangeLog>

src/main/resources/config/liquibase/master.xml

@@ -48,10 +48,11 @@
     <include file="classpath:config/liquibase/changelog/20250911170100_changelog.xml" relativeToChangelogFile="false"/>
     <include file="classpath:config/liquibase/changelog/20250920163252_changelog.xml" relativeToChangelogFile="false"/>
     <include file="classpath:config/liquibase/changelog/20250930145942_changelog.xml" relativeToChangelogFile="false"/>
-    <include file="classpath:config/liquibase/changelog/20251017200800_changelog.xml" relativeToChangelogFile="false"/>
     <include file="classpath:config/liquibase/changelog/20251012122800_changelog.xml" relativeToChangelogFile="false"/>
-    <include file="classpath:config/liquibase/changelog/20251023184348_changelog.xml" relativeToChangelogFile="false"/>
+    <include file="classpath:config/liquibase/changelog/20251017200800_changelog.xml" relativeToChangelogFile="false"/>
     <include file="classpath:config/liquibase/changelog/20251020175436_changelog.xml" relativeToChangelogFile="false"/>
+    <include file="classpath:config/liquibase/changelog/20251023184348_changelog.xml" relativeToChangelogFile="false"/>
+    <include file="classpath:config/liquibase/changelog/20251024184500_changelog.xml" relativeToChangelogFile="false"/>
     <include file="classpath:config/liquibase/changelog/20251106150715_changelog.xml" relativeToChangelogFile="false"/>
     <include file="classpath:config/liquibase/changelog/20251113185215_changelog.xml" relativeToChangelogFile="false"/>
     <!-- NOTE: please use the format "YYYYMMDDhhmmss_changelog.xml", i.e. year month day hour minutes seconds and not something else! -->

src/main/webapp/app/core/course/overview/courses.route.ts

@@ -273,6 +273,17 @@ export const courseRoutes: Routes = [
                 },
                 canActivate: [UserRouteAccessService, CourseOverviewGuard],
                 children: [
+                    {
+                        path: 'tutorial-lectures/:lectureId',
+                        data: {
+                            authorities: [Authority.USER],
+                            pageTitle: 'overview.lectures',
+                            hasSidebar: true,
+                            showRefreshButton: true,
+                        },
+                        canActivate: [UserRouteAccessService],
+                        loadComponent: () => import('app/lecture/overview/course-lectures/details/course-lecture-details.component').then((m) => m.CourseLectureDetailsComponent),
+                    },
                     {
                         path: ':tutorialGroupId',
                         loadComponent: () =>

src/main/webapp/app/core/course/overview/services/course-overview.service.spec.ts

@@ -189,33 +189,122 @@ describe('CourseOverviewService', () => {
         expect(groupedLectures['current'].entityData[0].title).toBe('Algorithms');
     });
 
-    it('should return undefined if lectures array is undefined', () => {
-        expect(courseOverviewService.getUpcomingLecture(undefined)).toBeUndefined();
+    describe('getUpcomingLecture', () => {
+        it('should return undefined if lectures array is undefined', () => {
+            expect(courseOverviewService.getUpcomingLecture(undefined)).toBeUndefined();
+        });
+
+        it('should return undefined if lectures array is empty', () => {
+            expect(courseOverviewService.getUpcomingLecture([])).toBeUndefined();
+        });
+
+        it('should handle all past lectures', () => {
+            const pastLectures: Lecture[] = [
+                { id: 1, title: 'Past Lecture 1', startDate: dayjs().subtract(2, 'day') },
+                { id: 2, title: 'Past Lecture 2', startDate: dayjs().subtract(1, 'day') },
+            ];
+            const upcomingLecture = courseOverviewService.getUpcomingLecture(pastLectures);
+
+            expect(upcomingLecture?.id).toBe(2);
+        });
+
+        it('should correctly identify the lecture furthest in the future', () => {
+            const lectures: Lecture[] = [
+                { id: 1, title: 'Past Lecture', startDate: dayjs().subtract(1, 'day') },
+                { id: 2, title: 'Upcoming Lecture', startDate: dayjs().add(1, 'day') },
+                { id: 3, title: 'Far Future Lecture', startDate: dayjs().add(2, 'weeks') },
+            ];
+            const upcomingLecture = courseOverviewService.getUpcomingLecture(lectures);
+
+            expect(upcomingLecture?.id).toBe(3);
+        });
     });
 
-    it('should return undefined if lectures array is empty', () => {
-        expect(courseOverviewService.getUpcomingLecture([])).toBeUndefined();
+    describe('getUpcomingTutorialGroup', () => {
+        it('should return undefined if tutorial groups are undefined', () => {
+            const result = courseOverviewService.getUpcomingTutorialGroup(undefined);
+            expect(result).toBeUndefined();
+        });
+
+        it('should return undefined if there are no future tutorial groups', () => {
+            const now = dayjs();
+            const futureTutorialGroups: TutorialGroup[] = [
+                { id: 1, nextSession: { start: now.subtract(1, 'day') } },
+                { id: 2, nextSession: { start: now.subtract(2, 'day') } },
+            ];
+            const result = courseOverviewService.getUpcomingTutorialGroup(futureTutorialGroups);
+            expect(result).toBeUndefined();
+        });
+
+        it('should return upcoming of tutorial groups', () => {
+            const now = dayjs();
+            const futureTutorialGroups: TutorialGroup[] = [
+                { id: 1, nextSession: { start: now.add(1, 'day') } },
+                { id: 2, nextSession: { start: now.add(2, 'day') } },
+            ];
+            const result = courseOverviewService.getUpcomingTutorialGroup(futureTutorialGroups);
+            expect(result?.id).toBe(1);
+        });
     });
 
-    it('should handle all past lectures', () => {
-        const pastLectures: Lecture[] = [
-            { id: 1, title: 'Past Lecture 1', startDate: dayjs().subtract(2, 'day') },
-            { id: 2, title: 'Past Lecture 2', startDate: dayjs().subtract(1, 'day') },
+    it('should map lectures correctly to sidebar card elements', () => {
+        const translateService = TestBed.inject(TranslateService);
+        jest.spyOn(translateService, 'instant').mockReturnValue('No Date');
+        const firstLectureStart = dayjs('2025-01-01T00:00:00Z');
+        const lectures: Lecture[] = [
+            { id: 1, title: 'Lecture 1', startDate: dayjs('2025-01-01T00:00:00Z') },
+            { id: 2, title: 'Lecture 2' },
         ];
-        const upcomingLecture = courseOverviewService.getUpcomingLecture(pastLectures);
 
-        expect(upcomingLecture?.id).toBe(2);
+        const result = courseOverviewService.mapLecturesToSidebarCardElements(lectures);
+
+        expect(result).toEqual([
+            {
+                title: 'Lecture 1',
+                id: 1,
+                subtitleLeft: firstLectureStart.format('MMM DD, YYYY'),
+                size: 'M',
+                startDate: firstLectureStart,
+            },
+            {
+                title: 'Lecture 2',
+                id: 2,
+                subtitleLeft: 'No Date',
+                size: 'M',
+                startDate: undefined,
+            },
+        ]);
     });
 
-    it('should correctly identify the lecture furthest in the future', () => {
+    it('should map tutorial lectures correctly to sidebar card elements', () => {
+        const translateService = TestBed.inject(TranslateService);
+        jest.spyOn(translateService, 'instant').mockReturnValue('No Date');
+        const firstLectureStart = dayjs('2025-01-01T00:00:00Z');
         const lectures: Lecture[] = [
-            { id: 1, title: 'Past Lecture', startDate: dayjs().subtract(1, 'day') },
-            { id: 2, title: 'Upcoming Lecture', startDate: dayjs().add(1, 'day') },
-            { id: 3, title: 'Far Future Lecture', startDate: dayjs().add(2, 'weeks') },
+            { id: 1, title: 'Lecture 1', startDate: dayjs('2025-01-01T00:00:00Z'), isTutorialLecture: true },
+            { id: 2, title: 'Lecture 2', isTutorialLecture: true },
         ];
-        const upcomingLecture = courseOverviewService.getUpcomingLecture(lectures);
 
-        expect(upcomingLecture?.id).toBe(3);
+        const result = courseOverviewService.mapLecturesToSidebarCardElements(lectures);
+
+        expect(result).toEqual([
+            {
+                title: 'Lecture 1',
+                id: 1,
+                targetComponentSubRoute: 'tutorial-lectures',
+                subtitleLeft: firstLectureStart.format('MMM DD, YYYY'),
+                size: 'M',
+                startDate: firstLectureStart,
+            },
+            {
+                title: 'Lecture 2',
+                id: 2,
+                targetComponentSubRoute: 'tutorial-lectures',
+                subtitleLeft: 'No Date',
+                size: 'M',
+                startDate: undefined,
+            },
+        ]);
     });
 
     it('should group exercises by start date and map to sidebar card elements', () => {