Communication: Allow users to mark all channels as read

src/main/java/de/tum/cit/aet/artemis/communication/service/conversation/ChannelService.java

@@ -450,4 +450,11 @@ public Channel createFeedbackChannel(Course course, Long exerciseId, ChannelDTO
 
         return createdChannel;
     }
+
+    public void markAllChannelsOfCourseAsRead(Course course, User requestingUser) {
+        var channels = channelRepository.findChannelsByCourseId(course.getId());
+        for (Channel channel : channels) {
+            conversationService.markConversationAsRead(channel, requestingUser);
+        }
+    }
 }

src/main/java/de/tum/cit/aet/artemis/communication/service/conversation/ConversationService.java

@@ -444,6 +444,13 @@ public void setIsMuted(Long conversationId, User requestingUser, boolean isMuted
         conversationParticipantRepository.save(conversationParticipant);
     }
 
+    public void markConversationAsRead(Channel channel, User requestingUser) {
+        var conversationParticipant = getOrCreateConversationParticipant(channel.getId(), requestingUser);
+        conversationParticipant.setLastRead(ZonedDateTime.now());
+        conversationParticipant.setUnreadMessagesCount(0L);
+        conversationParticipantRepository.save(conversationParticipant);
+    }
+
     /**
      * The user can select one of these roles to filter the conversation members by role
      */

src/main/java/de/tum/cit/aet/artemis/communication/web/conversation/ChannelResource.java

@@ -496,6 +496,24 @@ public ResponseEntity<ChannelDTO> createFeedbackChannel(@PathVariable Long cours
         return ResponseEntity.created(new URI("/api/channels/" + createdChannel.getId())).body(conversationDTOService.convertChannelToDTO(requestingUser, createdChannel));
     }
 
+    /**
+     * PUT /api/courses/:courseId/channels/mark-as-read: Marks all channels of a course as read for the current user.
+     *
+     * @param courseId the id of the course.
+     * @return ResponseEntity with status 200 (Ok).
+     */
+    @PutMapping("{courseId}/channels/mark-as-read")
+    @EnforceAtLeastStudent
+    public ResponseEntity<ChannelDTO> markAllChannelsOfCourseAsRead(@PathVariable Long courseId) {
+        log.debug("REST request to mark all channels of course {} as read", courseId);
+        var requestingUser = userRepository.getUserWithGroupsAndAuthorities();
+        var course = courseRepository.findByIdElseThrow(courseId);
+        checkCommunicationEnabledElseThrow(course);
+        authorizationCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.STUDENT, course, requestingUser);
+        channelService.markAllChannelsOfCourseAsRead(course, requestingUser);
+        return ResponseEntity.ok().build();
+    }
+
     private void checkEntityIdMatchesPathIds(Channel channel, Optional<Long> courseId, Optional<Long> conversationId) {
         courseId.ifPresent(courseIdValue -> {
             if (!channel.getCourse().getId().equals(courseIdValue)) {

src/main/webapp/app/overview/course-conversations/course-conversations.component.html

@@ -30,6 +30,7 @@
                     [courseId]="course.id"
                     [sidebarData]="sidebarData"
                     (onCreateChannelPressed)="openCreateChannelDialog()"
+                    (onMarkAllChannelsAsRead)="markAllChannelAsRead()"
                     (onBrowsePressed)="openChannelOverviewDialog()"
                     (onDirectChatPressed)="openCreateOneToOneChatDialog()"
                     (onGroupChatPressed)="openCreateGroupChatDialog()"

src/main/webapp/app/overview/course-conversations/course-conversations.component.ts

@@ -521,6 +521,19 @@ export class CourseConversationsComponent implements OnInit, OnDestroy {
             });
     }
 
+    markAllChannelAsRead() {
+        this.metisConversationService.markAllChannelsAsRead(this.course).subscribe({
+            complete: () => {
+                this.metisConversationService.forceRefresh().subscribe({
+                    complete: () => {
+                        this.prepareSidebarData();
+                        this.closeSidebarOnMobile();
+                    },
+                });
+            },
+        });
+    }
+
     openChannelOverviewDialog() {
         const subType = null;
         const modalRef: NgbModalRef = this.modalService.open(ChannelsOverviewDialogComponent, defaultFirstLayerDialogOptions);

src/main/webapp/app/shared/metis/conversations/conversation.service.ts

@@ -184,4 +184,8 @@ export class ConversationService {
         params = params.set('page', String(page));
         return params.set('size', String(size));
     };
+
+    markAllChannelsAsRead(courseId: number) {
+        return this.http.put<void>(`${this.resourceUrl}${courseId}/channels/mark-as-read`, { observe: 'response' });
+    }
 }

src/main/webapp/app/shared/metis/metis-conversation.service.ts

@@ -470,4 +470,17 @@ export class MetisConversationService implements OnDestroy {
     static getLinkForConversation(courseId: number): RouteComponents {
         return ['/courses', courseId, 'communication'];
     }
+
+    markAllChannelsAsRead(course: Course | undefined) {
+        if (!course?.id) {
+            return of();
+        }
+
+        return this.conversationService.markAllChannelsAsRead(course.id).pipe(
+            catchError((errorResponse: HttpErrorResponse) => {
+                onError(this.alertService, errorResponse);
+                return of();
+            }),
+        );
+    }
 }

src/main/webapp/app/shared/sidebar/sidebar.component.html

@@ -45,6 +45,10 @@
                                         <fa-icon [icon]="faSearch" class="item-icon"></fa-icon>
                                         <span jhiTranslate="artemisApp.courseOverview.sidebar.browseChannels"></span>
                                     </button>
+                                    <button (click)="markAllMessagesAsChecked()" class="p-2" ngbDropdownItem>
+                                        <fa-icon [icon]="faCheck" class="item-icon"></fa-icon>
+                                        <span jhiTranslate="artemisApp.courseOverview.sidebar.setChannelAsRead"></span>
+                                    </button>
                                 </div>
                             </div>
                         }

src/main/webapp/app/shared/sidebar/sidebar.component.ts

@@ -1,5 +1,5 @@
 import { Component, EventEmitter, Input, OnChanges, OnDestroy, OnInit, Output, effect, input, output } from '@angular/core';
-import { faFilter, faFilterCircleXmark, faHashtag, faPeopleGroup, faPlusCircle, faSearch, faUser } from '@fortawesome/free-solid-svg-icons';
+import { faCheck, faFilter, faFilterCircleXmark, faHashtag, faPeopleGroup, faPlusCircle, faSearch, faUser } from '@fortawesome/free-solid-svg-icons';
 import { ActivatedRoute, Params } from '@angular/router';
 import { Subscription, distinctUntilChanged } from 'rxjs';
 import { ProfileService } from '../layouts/profiles/profile.service';
@@ -28,6 +28,7 @@ export class SidebarComponent implements OnDestroy, OnChanges, OnInit {
     onGroupChatPressed = output<void>();
     onBrowsePressed = output<void>();
     onCreateChannelPressed = output<void>();
+    onMarkAllChannelsAsRead = output<void>();
     @Input() searchFieldEnabled: boolean = true;
     @Input() sidebarData: SidebarData;
     @Input() courseId?: number;
@@ -61,6 +62,7 @@ export class SidebarComponent implements OnDestroy, OnChanges, OnInit {
     readonly faPlusCircle = faPlusCircle;
     readonly faSearch = faSearch;
     readonly faHashtag = faHashtag;
+    readonly faCheck = faCheck;
 
     sidebarDataBeforeFiltering: SidebarData;
 
@@ -195,4 +197,8 @@ export class SidebarComponent implements OnDestroy, OnChanges, OnInit {
             achievablePoints: scoreAndPointsFilterOptions?.achievablePoints,
         };
     }
+
+    markAllMessagesAsChecked() {
+        this.onMarkAllChannelsAsRead.emit();
+    }
 }

src/main/webapp/i18n/de/student-dashboard.json

@@ -82,7 +82,8 @@
                 "createDirectChat": "Direkt-Chat erstellen",
                 "groupChats": "Gruppenchats",
                 "directMessages": "Direktnachrichten",
-                "filterConversationPlaceholder": "Konversationen filtern"
+                "filterConversationPlaceholder": "Konversationen filtern",
+                "setChannelAsRead": "Alle Kanäle als gelesen markieren"
             },
             "menu": {
                 "exercises": "Aufgaben",

src/main/webapp/i18n/en/student-dashboard.json

@@ -82,7 +82,8 @@
                 "createDirectChat": "Create direct chat",
                 "groupChats": "Group Chats",
                 "directMessages": "Direct Messages",
-                "filterConversationPlaceholder": "Filter conversations"
+                "filterConversationPlaceholder": "Filter conversations",
+                "setChannelAsRead": "Mark all channels as read"
             },
             "menu": {
                 "exercises": "Exercises",

src/test/java/de/tum/cit/aet/artemis/communication/ChannelIntegrationTest.java

@@ -7,6 +7,7 @@
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
 
@@ -21,12 +22,17 @@
 import org.springframework.security.test.context.support.WithMockUser;
 import org.springframework.util.LinkedMultiValueMap;
 
+import de.tum.cit.aet.artemis.communication.domain.ConversationParticipant;
 import de.tum.cit.aet.artemis.communication.domain.conversation.Channel;
 import de.tum.cit.aet.artemis.communication.dto.ChannelDTO;
 import de.tum.cit.aet.artemis.communication.dto.ChannelIdAndNameDTO;
 import de.tum.cit.aet.artemis.communication.dto.FeedbackChannelRequestDTO;
 import de.tum.cit.aet.artemis.communication.dto.MetisCrudAction;
+
+import de.tum.cit.aet.artemis.communication.service.conversation.ChannelService;
+
 import de.tum.cit.aet.artemis.communication.service.conversation.ConversationService;
+
 import de.tum.cit.aet.artemis.communication.util.ConversationUtilService;
 import de.tum.cit.aet.artemis.core.domain.Course;
 import de.tum.cit.aet.artemis.core.domain.CourseInformationSharingConfiguration;
@@ -75,6 +81,9 @@ class ChannelIntegrationTest extends AbstractConversationTest {
     @Autowired
     private ProgrammingExerciseUtilService programmingExerciseUtilService;
 
+    @Autowired
+    private ChannelService channelService;
+
     @BeforeEach
     @Override
     void setupTestScenario() throws Exception {
@@ -973,6 +982,32 @@ void createFeedbackChannel_asInstructor_shouldCreateChannel() {
         assertThat(response.getDescription()).isEqualTo("Discussion channel for feedback");
     }
 
+    @Test
+    @WithMockUser(username = TEST_PREFIX + "instructor1", roles = "INSTRUCTOR")
+    void markAllChannelsAsRead() throws Exception {
+        // ensure there exist atleast two channel with unread messages in the course
+        ChannelDTO newChannel1 = createChannel(true, "channel1");
+        ChannelDTO newChannel2 = createChannel(true, "channel2");
+        List<Channel> channels = channelRepository.findChannelsByCourseId(exampleCourseId);
+        channels.forEach(channel -> {
+            addUsersToConversation(channel.getId(), "instructor1");
+            conversationParticipantRepository.findConversationParticipantsByConversationId(channel.getId()).forEach(conversationParticipant -> {
+                conversationParticipant.setUnreadMessagesCount(1L);
+                conversationParticipantRepository.save(conversationParticipant);
+            });
+        });
+
+        User requestingUser = userTestRepository.getUser();
+        request.put("/api/courses/" + exampleCourseId + "/channels/mark-as-read", null, HttpStatus.OK);
+        List<Channel> updatedChannels = channelRepository.findChannelsByCourseId(exampleCourseId);
+        updatedChannels.forEach(channel -> {
+            Optional<ConversationParticipant> conversationParticipant = conversationParticipantRepository.findConversationParticipantByConversationIdAndUserId(channel.getId(),
+                    requestingUser.getId());
+            assertThat(conversationParticipant.get().getUnreadMessagesCount()).isEqualTo(0L);
+        });
+
+    }
+
     private void testArchivalChangeWorks(ChannelDTO channel, boolean isPublicChannel, boolean shouldArchive) throws Exception {
         // prepare channel in db
         if (shouldArchive) {

src/test/javascript/spec/component/overview/course-conversations/course-conversations.component.spec.ts

@@ -580,6 +580,14 @@ examples.forEach((activeConversation) => {
             });
         });
 
+        it('should mark all channels as read', () => {
+            const markAllChannelsAsRead = jest.spyOn(metisConversationService, 'markAllChannelsAsRead').mockReturnValue(of());
+            const forceRefresh = jest.spyOn(metisConversationService, 'forceRefresh');
+            component.markAllChannelAsRead();
+            expect(markAllChannelsAsRead).toHaveBeenCalledOnce();
+            expect(forceRefresh).toHaveBeenCalledTimes(2);
+        });
+
         describe('conversation selection', () => {
             it('should handle numeric conversationId', () => {
                 component.onConversationSelected(123);

src/test/javascript/spec/component/overview/course-conversations/services/metis-conversation.service.spec.ts

@@ -406,4 +406,10 @@ describe('MetisConversationService', () => {
         metisConversationService.markAsRead(2);
         expect(metisConversationService['conversationsOfUser'][1].unreadMessagesCount).toBe(0);
     });
+
+    it('should call refresh after marking all channels as read', () => {
+        const markAllChannelAsReadSpy = jest.spyOn(conversationService, 'markAllChannelsAsRead').mockReturnValue(of());
+        metisConversationService.markAllChannelsAsRead(course);
+        expect(markAllChannelAsReadSpy).toHaveBeenCalledOnce();
+    });
 });