Communication: Allow tutors to propose FAQ

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

@@ -12,6 +12,7 @@
 import org.springframework.transaction.annotation.Transactional;
 
 import de.tum.cit.aet.artemis.communication.domain.Faq;
+import de.tum.cit.aet.artemis.communication.domain.FaqState;
 import de.tum.cit.aet.artemis.core.repository.base.ArtemisJpaRepository;
 
 /**
@@ -30,6 +31,8 @@ public interface FaqRepository extends ArtemisJpaRepository<Faq, Long> {
             """)
     Set<String> findAllCategoriesByCourseId(@Param("courseId") Long courseId);
 
+    Set<Faq> findAllByCourseIdAndFaqState(Long courseId, FaqState faqState);
+
     @Transactional
     @Modifying
     void deleteAllByCourseId(Long courseId);

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

@@ -23,14 +23,17 @@
 import org.springframework.web.bind.annotation.RestController;
 
 import de.tum.cit.aet.artemis.communication.domain.Faq;
+import de.tum.cit.aet.artemis.communication.domain.FaqState;
 import de.tum.cit.aet.artemis.communication.dto.FaqDTO;
 import de.tum.cit.aet.artemis.communication.repository.FaqRepository;
 import de.tum.cit.aet.artemis.core.domain.Course;
+import de.tum.cit.aet.artemis.core.exception.AccessForbiddenException;
 import de.tum.cit.aet.artemis.core.exception.BadRequestAlertException;
 import de.tum.cit.aet.artemis.core.repository.CourseRepository;
 import de.tum.cit.aet.artemis.core.security.Role;
-import de.tum.cit.aet.artemis.core.security.annotations.EnforceAtLeastInstructor;
-import de.tum.cit.aet.artemis.core.security.annotations.EnforceAtLeastStudent;
+import de.tum.cit.aet.artemis.core.security.annotations.enforceRoleInCourse.EnforceAtLeastInstructorInCourse;
+import de.tum.cit.aet.artemis.core.security.annotations.enforceRoleInCourse.EnforceAtLeastStudentInCourse;
+import de.tum.cit.aet.artemis.core.security.annotations.enforceRoleInCourse.EnforceAtLeastTutorInCourse;
 import de.tum.cit.aet.artemis.core.service.AuthorizationCheckService;
 import de.tum.cit.aet.artemis.core.util.HeaderUtil;
 
@@ -56,10 +59,9 @@ public class FaqResource {
     private final FaqRepository faqRepository;
 
     public FaqResource(CourseRepository courseRepository, AuthorizationCheckService authCheckService, FaqRepository faqRepository) {
-
+        this.faqRepository = faqRepository;
         this.courseRepository = courseRepository;
         this.authCheckService = authCheckService;
-        this.faqRepository = faqRepository;
     }
 
     /**
@@ -72,18 +74,16 @@ public FaqResource(CourseRepository courseRepository, AuthorizationCheckService
      * @throws URISyntaxException if the Location URI syntax is incorrect
      */
     @PostMapping("courses/{courseId}/faqs")
-    @EnforceAtLeastInstructor
+    @EnforceAtLeastTutorInCourse
     public ResponseEntity<FaqDTO> createFaq(@RequestBody Faq faq, @PathVariable Long courseId) throws URISyntaxException {
         log.debug("REST request to save Faq : {}", faq);
         if (faq.getId() != null) {
             throw new BadRequestAlertException("A new faq cannot already have an ID", ENTITY_NAME, "idExists");
         }
-
+        checkPriviledgeForAcceptedElseThrow(faq, courseId);
         if (faq.getCourse() == null || !faq.getCourse().getId().equals(courseId)) {
             throw new BadRequestAlertException("Course ID in path and FAQ do not match", ENTITY_NAME, "courseIdMismatch");
         }
-        authCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.INSTRUCTOR, faq.getCourse(), null);
-
         Faq savedFaq = faqRepository.save(faq);
         FaqDTO dto = new FaqDTO(savedFaq);
         return ResponseEntity.created(new URI("/api/courses/" + courseId + "/faqs/" + savedFaq.getId())).body(dto);
@@ -99,14 +99,15 @@ public ResponseEntity<FaqDTO> createFaq(@RequestBody Faq faq, @PathVariable Long
      *         if the faq is not valid or if the faq course id does not match with the path variable
      */
     @PutMapping("courses/{courseId}/faqs/{faqId}")
-    @EnforceAtLeastInstructor
+    @EnforceAtLeastTutorInCourse
     public ResponseEntity<FaqDTO> updateFaq(@RequestBody Faq faq, @PathVariable Long faqId, @PathVariable Long courseId) {
         log.debug("REST request to update Faq : {}", faq);
         if (faqId == null || !faqId.equals(faq.getId())) {
             throw new BadRequestAlertException("Id of FAQ and path must match", ENTITY_NAME, "idNull");
         }
-        authCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.INSTRUCTOR, faq.getCourse(), null);
+        checkPriviledgeForAcceptedElseThrow(faq, courseId);
         Faq existingFaq = faqRepository.findByIdElseThrow(faqId);
+        checkPriviledgeForAcceptedElseThrow(existingFaq, courseId);
         if (!Objects.equals(existingFaq.getCourse().getId(), courseId)) {
             throw new BadRequestAlertException("Course ID of the FAQ provided courseID must match", ENTITY_NAME, "idNull");
         }
@@ -115,6 +116,19 @@ public ResponseEntity<FaqDTO> updateFaq(@RequestBody Faq faq, @PathVariable Long
         return ResponseEntity.ok().body(dto);
     }
 
+    /**
+     * @param faq      the faq to be checked *
+     * @param courseId the id of the course the faq belongs to
+     * @throws AccessForbiddenException if the user is not an instructor
+     *
+     */
+    private void checkPriviledgeForAcceptedElseThrow(Faq faq, Long courseId) {
+        if (faq.getFaqState() == FaqState.ACCEPTED) {
+            Course course = courseRepository.findByIdElseThrow(courseId);
+            authCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.INSTRUCTOR, course, null);
+        }
+    }
+
     /**
      * GET /courses/:courseId/faqs/:faqId : get the faq with the id faqId.
      *
@@ -123,14 +137,13 @@ public ResponseEntity<FaqDTO> updateFaq(@RequestBody Faq faq, @PathVariable Long
      * @return the ResponseEntity with status 200 (OK) and with body the faq, or with status 404 (Not Found)
      */
     @GetMapping("courses/{courseId}/faqs/{faqId}")
-    @EnforceAtLeastStudent
+    @EnforceAtLeastStudentInCourse
     public ResponseEntity<FaqDTO> getFaq(@PathVariable Long faqId, @PathVariable Long courseId) {
         log.debug("REST request to get faq {}", faqId);
         Faq faq = faqRepository.findByIdElseThrow(faqId);
         if (faq.getCourse() == null || !faq.getCourse().getId().equals(courseId)) {
             throw new BadRequestAlertException("Course ID in path and FAQ do not match", ENTITY_NAME, "courseIdMismatch");
         }
-        authCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.STUDENT, faq.getCourse(), null);
         FaqDTO dto = new FaqDTO(faq);
         return ResponseEntity.ok(dto);
     }
@@ -143,12 +156,11 @@ public ResponseEntity<FaqDTO> getFaq(@PathVariable Long faqId, @PathVariable Lon
      * @return the ResponseEntity with status 200 (OK)
      */
     @DeleteMapping("courses/{courseId}/faqs/{faqId}")
-    @EnforceAtLeastInstructor
+    @EnforceAtLeastInstructorInCourse
     public ResponseEntity<Void> deleteFaq(@PathVariable Long faqId, @PathVariable Long courseId) {
 
         log.debug("REST request to delete faq {}", faqId);
         Faq existingFaq = faqRepository.findByIdElseThrow(faqId);
-        authCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.INSTRUCTOR, existingFaq.getCourse(), null);
         if (!Objects.equals(existingFaq.getCourse().getId(), courseId)) {
             throw new BadRequestAlertException("Course ID of the FAQ provided courseID must match", ENTITY_NAME, "idNull");
         }
@@ -163,30 +175,40 @@ public ResponseEntity<Void> deleteFaq(@PathVariable Long faqId, @PathVariable Lo
      * @return the ResponseEntity with status 200 (OK) and the list of faqs in body
      */
     @GetMapping("courses/{courseId}/faqs")
-    @EnforceAtLeastStudent
+    @EnforceAtLeastStudentInCourse
     public ResponseEntity<Set<FaqDTO>> getFaqForCourse(@PathVariable Long courseId) {
         log.debug("REST request to get all Faqs for the course with id : {}", courseId);
-
-        Course course = courseRepository.findByIdElseThrow(courseId);
-        authCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.STUDENT, course, null);
         Set<Faq> faqs = faqRepository.findAllByCourseId(courseId);
         Set<FaqDTO> faqDTOS = faqs.stream().map(FaqDTO::new).collect(Collectors.toSet());
         return ResponseEntity.ok().body(faqDTOS);
     }
 
+    /**
+     * GET /courses/:courseId/faq-status/:faqState : get all the faqs of a course in the specified status
+     *
+     * @param courseId the courseId of the course for which all faqs should be returned
+     * @param faqState the state of all returned FAQs
+     * @return the ResponseEntity with status 200 (OK) and the list of faqs in body
+     */
+    @GetMapping("courses/{courseId}/faq-state/{faqState}")
+    @EnforceAtLeastStudentInCourse
+    public ResponseEntity<Set<FaqDTO>> getAllFaqsForCourseByStatus(@PathVariable Long courseId, @PathVariable FaqState faqState) {
+        log.debug("REST request to get all Faqs for the course with id : " + courseId + "and status " + faqState, courseId);
+        Set<Faq> faqs = faqRepository.findAllByCourseIdAndFaqState(courseId, faqState);
+        Set<FaqDTO> faqDTOS = faqs.stream().map(FaqDTO::new).collect(Collectors.toSet());
+        return ResponseEntity.ok().body(faqDTOS);
+    }
+
     /**
      * GET /courses/:courseId/faq-categories : get all the faq categories of a course
      *
      * @param courseId the courseId of the course for which all faq categories should be returned
      * @return the ResponseEntity with status 200 (OK) and the list of faqs in body
      */
     @GetMapping("courses/{courseId}/faq-categories")
-    @EnforceAtLeastStudent
+    @EnforceAtLeastStudentInCourse
     public ResponseEntity<Set<String>> getFaqCategoriesForCourse(@PathVariable Long courseId) {
         log.debug("REST request to get all Faq Categories for the course with id : {}", courseId);
-
-        Course course = courseRepository.findByIdElseThrow(courseId);
-        authCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.STUDENT, course, null);
         Set<String> faqs = faqRepository.findAllCategoriesByCourseId(courseId);
 
         return ResponseEntity.ok().body(faqs);

src/main/webapp/app/course/manage/course-management-tab-bar/course-management-tab-bar.component.html

@@ -72,7 +72,7 @@
                     <span class="tab-link-text" jhiTranslate="entity.action.scores"></span>
                 </a>
             }
-            @if (course.isAtLeastInstructor && course.faqEnabled) {
+            @if (course.isAtLeastTutor && course.faqEnabled) {
                 <a class="tab-link" [routerLink]="['/course-management', course.id, 'faqs']" routerLinkActive="active">
                     <fa-icon [icon]="faQuestion" />
                     <span class="tab-link-text" jhiTranslate="entity.action.faq"></span>

src/main/webapp/app/course/manage/course-management.route.ts

@@ -347,7 +347,7 @@ export const courseManagementState: Routes = [
                                     course: CourseManagementResolve,
                                 },
                                 data: {
-                                    authorities: [Authority.EDITOR, Authority.INSTRUCTOR, Authority.ADMIN],
+                                    authorities: [Authority.TA, Authority.EDITOR, Authority.INSTRUCTOR, Authority.ADMIN],
                                     pageTitle: 'artemisApp.faq.home.title',
                                 },
                                 canActivate: [UserRouteAccessService],
@@ -363,7 +363,7 @@ export const courseManagementState: Routes = [
                                         path: 'new',
                                         component: FaqUpdateComponent,
                                         data: {
-                                            authorities: [Authority.EDITOR, Authority.INSTRUCTOR, Authority.ADMIN],
+                                            authorities: [Authority.TA, Authority.EDITOR, Authority.INSTRUCTOR, Authority.ADMIN],
                                             pageTitle: 'global.generic.create',
                                         },
                                         canActivate: [UserRouteAccessService],
@@ -378,7 +378,7 @@ export const courseManagementState: Routes = [
                                                 path: 'edit',
                                                 component: FaqUpdateComponent,
                                                 data: {
-                                                    authorities: [Authority.EDITOR, Authority.INSTRUCTOR, Authority.ADMIN],
+                                                    authorities: [Authority.TA, Authority.EDITOR, Authority.INSTRUCTOR, Authority.ADMIN],
                                                     pageTitle: 'global.generic.edit',
                                                 },
                                                 canActivate: [UserRouteAccessService],

src/main/webapp/app/course/manage/overview/course-management-card.component.html

@@ -339,7 +339,7 @@ <h4 class="text-center no-exercises mt-3 fw-medium" jhiTranslate="artemisApp.cou
             </a>
         }
 
-        @if (course.isAtLeastInstructor && course.faqEnabled) {
+        @if (course.isAtLeastTutor && course.faqEnabled) {
             <a
                 [routerLink]="['/course-management', course.id, 'faqs']"
                 class="btn btn-info me-1 mb-1"

src/main/webapp/app/entities/faq.model.ts

@@ -3,9 +3,9 @@ import { Course } from 'app/entities/course.model';
 import { FaqCategory } from './faq-category.model';
 
 export enum FaqState {
-    ACCEPTED,
-    REJECTED,
-    PROPOSED,
+    ACCEPTED = 'ACCEPTED',
+    REJECTED = 'REJECTED',
+    PROPOSED = 'PROPOSED',
 }
 
 export class Faq implements BaseEntity {

src/main/webapp/app/faq/faq-update.component.ts

@@ -16,6 +16,7 @@ import { ArtemisMarkdownEditorModule } from 'app/shared/markdown-editor/markdown
 import { ArtemisCategorySelectorModule } from 'app/shared/category-selector/category-selector.module';
 import { ArtemisSharedModule } from 'app/shared/shared.module';
 import { ArtemisSharedComponentModule } from 'app/shared/components/shared-component.module';
+import { AccountService } from 'app/core/auth/account.service';
 
 @Component({
     selector: 'jhi-faq-update',
@@ -31,19 +32,21 @@ export class FaqUpdateComponent implements OnInit {
     existingCategories: FaqCategory[];
     faqCategories: FaqCategory[];
     courseId: number;
+    isAtLeastInstructor: boolean = false;
     domainActionsDescription = [new FormulaAction()];
 
     // Icons
-    faQuestionCircle = faQuestionCircle;
-    faSave = faSave;
-    faBan = faBan;
+    readonly faQuestionCircle = faQuestionCircle;
+    readonly faSave = faSave;
+    readonly faBan = faBan;
 
     private alertService = inject(AlertService);
     private faqService = inject(FaqService);
     private activatedRoute = inject(ActivatedRoute);
     private navigationUtilService = inject(ArtemisNavigationUtilService);
     private router = inject(Router);
     private translateService = inject(TranslateService);
+    private accountService = inject(AccountService);
 
     ngOnInit() {
         this.isSaving = false;
@@ -56,6 +59,7 @@ export class FaqUpdateComponent implements OnInit {
             if (course) {
                 this.faq.course = course;
                 this.loadCourseFaqCategories(course.id);
+                this.isAtLeastInstructor = this.accountService.isAtLeastInstructorInCourse(course);
             }
             this.faqCategories = faq?.categories ? faq.categories : [];
         });
@@ -77,10 +81,10 @@ export class FaqUpdateComponent implements OnInit {
      */
     save() {
         this.isSaving = true;
+        this.faq.faqState = this.isAtLeastInstructor ? FaqState.ACCEPTED : FaqState.PROPOSED;
         if (this.faq.id !== undefined) {
             this.subscribeToSaveResponse(this.faqService.update(this.courseId, this.faq));
         } else {
-            this.faq.faqState = FaqState.ACCEPTED;
             this.subscribeToSaveResponse(this.faqService.create(this.courseId, this.faq));
         }
     }
@@ -107,17 +111,28 @@ export class FaqUpdateComponent implements OnInit {
                     if (faqBody) {
                         this.faq = faqBody;
                     }
-                    this.alertService.success(this.translateService.instant('artemisApp.faq.created', { id: faq.id }));
+                    this.showSuccessAlert(faq, false);
                     this.router.navigate(['course-management', this.courseId, 'faqs']);
                 },
             });
         } else {
-            this.isSaving = false;
-            this.alertService.success(this.translateService.instant('artemisApp.faq.updated', { id: faq.id }));
+            this.showSuccessAlert(faq, true);
             this.router.navigate(['course-management', this.courseId, 'faqs']);
         }
     }
 
+    private showSuccessAlert(faq: Faq, newlyCreated: boolean): void {
+        let messageKey: string;
+
+        if (this.isAtLeastInstructor) {
+            messageKey = newlyCreated ? 'artemisApp.faq.updated' : 'artemisApp.faq.created';
+        } else {
+            console.log(faq.id);
+            messageKey = newlyCreated ? 'artemisApp.faq.proposedChange' : 'artemisApp.faq.proposed';
+        }
+        this.alertService.success(messageKey, { title: faq.questionTitle });
+    }
+
     /**
      * Action on unsuccessful faq creation or edit
      * @param errorRes the errorRes handed to the alert service