Feature: Implement FAQ system to Artemis

src/main/java/de/tum/cit/aet/artemis/communication/domain/Faq.java

@@ -0,0 +1,99 @@
+package de.tum.cit.aet.artemis.communication.domain;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import jakarta.persistence.CollectionTable;
+import jakarta.persistence.Column;
+import jakarta.persistence.ElementCollection;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+import de.tum.cit.aet.artemis.core.domain.AbstractAuditingEntity;
+import de.tum.cit.aet.artemis.core.domain.Course;
+
+/**
+ * A FAQ.
+ */
+@Entity
+@Table(name = "faq")
+@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
+@JsonInclude(JsonInclude.Include.NON_EMPTY)
+public class Faq extends AbstractAuditingEntity {
+
+    @Column(name = "question_title")
+    private String questionTitle;
+
+    @Column(name = "question_answer")
+    private String questionAnswer;
+
+    @ElementCollection(fetch = FetchType.EAGER)
+    @CollectionTable(name = "faq_categories", joinColumns = @JoinColumn(name = "faq_id"))
+    @Column(name = "categories")
+    private Set<String> categories = new HashSet<>();
+
+    @Enumerated(EnumType.STRING)
+    @Column(name = "faq_state")
+    private FaqState faqState;
+
+    @ManyToOne
+    @JsonIgnoreProperties(value = { "faqs" }, allowSetters = true)
+    private Course course;
+
+    public String getQuestionTitle() {
+        return questionTitle;
+    }
+
+    public void setQuestionTitle(String questionTitle) {
+        this.questionTitle = questionTitle;
+    }
+
+    public String getQuestionAnswer() {
+        return questionAnswer;
+    }
+
+    public void setQuestionAnswer(String questionAnswer) {
+        this.questionAnswer = questionAnswer;
+    }
+
+    public Course getCourse() {
+        return course;
+    }
+
+    public void setCourse(Course course) {
+        this.course = course;
+    }
+
+    public Set<String> getCategories() {
+        return categories;
+    }
+
+    public void setCategories(Set<String> categories) {
+        this.categories = categories;
+    }
+
+    public FaqState getFaqState() {
+        return faqState;
+    }
+
+    public void setFaqState(FaqState faqState) {
+        this.faqState = faqState;
+    }
+
+    @Override
+    public String toString() {
+        return "Faq{" + "id=" + getId() + ", title='" + getQuestionTitle() + "'" + ", description='" + getQuestionTitle() + "'" + ", faqState='" + getFaqState() + "}";
+    }
+
+}

src/main/java/de/tum/cit/aet/artemis/communication/domain/FaqState.java

@@ -0,0 +1,5 @@
+package de.tum.cit.aet.artemis.communication.domain;
+
+public enum FaqState {
+    ACCEPTED, REJECTED, PROPOSED
+}

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

@@ -0,0 +1,47 @@
+package de.tum.cit.aet.artemis.communication.repository;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
+
+import java.util.Set;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
+
+import de.tum.cit.aet.artemis.communication.domain.Faq;
+import de.tum.cit.aet.artemis.core.repository.base.ArtemisJpaRepository;
+
+/**
+ * Spring Data repository for the Faq entity.
+ */
+@Profile(PROFILE_CORE)
+@Repository
+public interface FaqRepository extends ArtemisJpaRepository<Faq, Long> {
+
+    @Query("""
+            SELECT faq
+            FROM Faq faq
+            WHERE faq.course.id = :courseId
+            """)
+    Set<Faq> findAllByCourseId(@Param("courseId") Long courseId);
+
+    @Query("""
+            SELECT DISTINCT faq.categories
+            FROM Faq faq
+            WHERE faq.course.id = :courseId
+            """)
+    Set<String> findAllCategoriesByCourseId(@Param("courseId") Long courseId);
+
+    @Transactional
+    @Modifying
+    @Query("""
+            DELETE
+            FROM Faq faq
+            WHERE faq.course.id = :courseId
+            """)
+    void deleteAllByCourseId(@Param("courseId") Long courseId);
+
+}

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

@@ -0,0 +1,52 @@
+package de.tum.cit.aet.artemis.communication.service;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
+
+import java.util.Optional;
+import java.util.Set;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Service;
+
+import de.tum.cit.aet.artemis.communication.domain.Faq;
+import de.tum.cit.aet.artemis.communication.repository.FaqRepository;
+
+/**
+ * REST service for managing Faqs.
+ */
+@Profile(PROFILE_CORE)
+@Service
+public class FaqService {
+
+    private final FaqRepository faqRepository;
+
+    public FaqService(FaqRepository faqRepository) {
+        this.faqRepository = faqRepository;
+    }
+
+    /**
+     * Deletes the given faq
+     *
+     * @param faqId the ID of the FAQ to be deleted
+     */
+    public void deleteById(long faqId) {
+        faqRepository.deleteById(faqId);
+
+    }
+
+    public Faq save(Faq faq) {
+        return faqRepository.save(faq);
+    }
+
+    public Set<String> findAllCategoriesByCourseId(long courseId) {
+        return faqRepository.findAllCategoriesByCourseId(courseId);
+    }
+
+    public Optional<Faq> findById(Long faqId) {
+        return faqRepository.findById(faqId);
+    }
+
+    public Set<Faq> findAllByCourseId(Long courseId) {
+        return faqRepository.findAllByCourseId(courseId);
+    }
+}

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

@@ -0,0 +1,180 @@
+package de.tum.cit.aet.artemis.communication.web;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.Set;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Profile;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import de.tum.cit.aet.artemis.communication.domain.Faq;
+import de.tum.cit.aet.artemis.communication.service.FaqService;
+import de.tum.cit.aet.artemis.core.domain.Course;
+import de.tum.cit.aet.artemis.core.exception.BadRequestAlertException;
+import de.tum.cit.aet.artemis.core.exception.EntityNotFoundException;
+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.service.AuthorizationCheckService;
+import de.tum.cit.aet.artemis.core.util.HeaderUtil;
+
+/**
+ * REST controller for managing Faqs.
+ */
+@Profile(PROFILE_CORE)
+@RestController
+@RequestMapping("api/")
+public class FaqResource {
+
+    private static final Logger log = LoggerFactory.getLogger(FaqResource.class);
+
+    private static final String ENTITY_NAME = "faq";
+
+    @Value("${jhipster.clientApp.name}")
+    private String applicationName;
+
+    private final FaqService faqService;
+
+    private final CourseRepository courseRepository;
+
+    private final AuthorizationCheckService authCheckService;
+
+    public FaqResource(FaqService faqService, CourseRepository courseRepository, AuthorizationCheckService authCheckService) {
+
+        this.faqService = faqService;
+        this.courseRepository = courseRepository;
+        this.authCheckService = authCheckService;
+    }
+
+    /**
+     * POST /faqs : Create a new faq.
+     *
+     * @param faq the faq to create
+     * @return the ResponseEntity with status 201 (Created) and with body the new faq, or with status 400 (Bad Request) if the faq has already an ID
+     * @throws URISyntaxException if the Location URI syntax is incorrect
+     */
+    @PostMapping("faqs")
+    @EnforceAtLeastInstructor
+    public ResponseEntity<Faq> createFaq(@RequestBody Faq faq) 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");
+        }
+        authCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.INSTRUCTOR, faq.getCourse(), null);
+
+        Faq savedFaq = faqService.save(faq);
+        return ResponseEntity.created(new URI("/api/faqs/" + savedFaq.getId())).body(savedFaq);
+    }
+
+    /**
+     * PUT /faqs/{faqId} : Updates an existing faq.
+     *
+     * @param faq   the faq to update
+     * @param faqId id of the faq to be updated
+     * @return the ResponseEntity with status 200 (OK) and with body the updated faq, or with status 400 (Bad Request) if the faq is not valid, or with status 500 (Internal
+     *         Server Error) if the faq couldn't be updated
+     */
+    @PutMapping("faqs/{faqId}")
+    @EnforceAtLeastInstructor
+    public ResponseEntity<Faq> updateFaq(@RequestBody Faq faq, @PathVariable Long faqId) {
+        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);
+        Faq existingFaq = faqService.findById(faqId).orElseThrow(() -> new EntityNotFoundException("FAQ not found", faqId));
+        Faq result = faqService.save(faq);
+        return ResponseEntity.ok().body(result);
+    }
+
+    /**
+     * GET /faqs/:faqId : get the "faqId" faq.
+     *
+     * @param faqId the faqId of the faq to retrieve
+     * @return the ResponseEntity with status 200 (OK) and with body the faq, or with status 404 (Not Found)
+     */
+    @GetMapping("faqs/{faqId}")
+    @EnforceAtLeastStudent
+    public ResponseEntity<Faq> getFaq(@PathVariable Long faqId) {
+        log.debug("REST request to get faq {}", faqId);
+        Faq faq = faqService.findById(faqId).orElseThrow(() -> new EntityNotFoundException("FAQ not found", faqId));
+        authCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.STUDENT, faq.getCourse(), null);
+        return ResponseEntity.ok(faq);
+    }
+
+    /**
+     * DELETE /faqs/:faqId : delete the "id" faq.
+     *
+     * @param faqId the id of the faq to delete
+     * @return the ResponseEntity with status 200 (OK)
+     */
+    @DeleteMapping("faqs/{faqId}")
+    @EnforceAtLeastInstructor
+    public ResponseEntity<Void> deleteFaq(@PathVariable Long faqId) {
+
+        log.debug("REST request to delete faq {}", faqId);
+        Faq faq = faqService.findById(faqId).orElseThrow(() -> new EntityNotFoundException("FAQ not found", faqId));
+        authCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.INSTRUCTOR, faq.getCourse(), null);
+        faqService.deleteById(faqId);
+        return ResponseEntity.ok().headers(HeaderUtil.createEntityDeletionAlert(applicationName, true, ENTITY_NAME, faqId.toString())).build();
+    }
+
+    /**
+     * GET /courses/:courseId/faqs : get all the faqs of a course
+     *
+     * @param courseId the courseId of the course for which all faqs should be returned
+     * @return the ResponseEntity with status 200 (OK) and the list of faqs in body
+     */
+    @GetMapping("courses/{courseId}/faqs")
+    @EnforceAtLeastStudent
+    public ResponseEntity<Set<Faq>> getFaqForCourse(@PathVariable Long courseId) {
+        log.debug("REST request to get all Faqs for the course with id : {}", courseId);
+
+        Course course = getCourseForRequest(courseId);
+        authCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.STUDENT, course, null);
+        Set<Faq> faqs = faqService.findAllByCourseId(courseId);
+        return ResponseEntity.ok().body(faqs);
+    }
+
+    /**
+     * GET /courses/:courseId/faqs : 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
+    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 = getCourseForRequest(courseId);
+        authCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.STUDENT, course, null);
+        Set<String> faqs = faqService.findAllCategoriesByCourseId(courseId);
+
+        return ResponseEntity.ok().body(faqs);
+    }
+
+    /**
+     *
+     * @param courseId the courseId of the course
+     * @return the course with the id courseId, unless it exists
+     */
+    private Course getCourseForRequest(Long courseId) {
+        return courseRepository.findByIdElseThrow(courseId);
+    }
+
+}