Communication: Allow user to forward messages

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

@@ -58,6 +58,17 @@ public Boolean doesResolvePost() {
         return resolvesPost;
     }
 
+    @Column(name = "has_forwarded_messages")
+    private boolean hasForwardedMessages;
+
+    public boolean getHasForwardedMessages() {
+        return hasForwardedMessages;
+    }
+
+    public void setHasForwardedMessages(boolean hasForwardedMessages) {
+        this.hasForwardedMessages = hasForwardedMessages;
+    }
+
     public void setResolvesPost(Boolean resolvesPost) {
         this.resolvesPost = resolvesPost;
     }

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

@@ -0,0 +1,100 @@
+package de.tum.cit.aet.artemis.communication.domain;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+import jakarta.validation.constraints.NotNull;
+
+import org.hibernate.annotations.Check;
+
+import com.fasterxml.jackson.annotation.JsonIncludeProperties;
+
+import de.tum.cit.aet.artemis.core.domain.DomainObject;
+
+@Entity
+@Table(name = "forwarded_message")
+@Check(constraints = "((destination_post_id IS NOT NULL AND destination_answer_id IS NULL) OR (destination_post_id IS NULL AND destination_answer_id IS NOT NULL))")
+public class ForwardedMessage extends DomainObject {
+
+    @Column(name = "source_id", nullable = false)
+    private long sourceId;
+
+    @NotNull
+    @Enumerated
+    @Column(name = "source_type", nullable = false)
+    private PostingType sourceType;
+
+    @ManyToOne
+    @JoinColumn(name = "destination_post_id")
+    @JsonIncludeProperties({ "id" })
+    private Post destinationPost;
+
+    @ManyToOne
+    @JoinColumn(name = "destination_answer_id")
+    @JsonIncludeProperties({ "id" })
+    private AnswerPost destinationAnswerPost;
+
+    public ForwardedMessage() {
+    }
+
+    public ForwardedMessage(Long sourceId, PostingType sourceType, Post destinationPost, AnswerPost destinationAnswerPost) {
+        if (sourceId == null) {
+            throw new IllegalArgumentException("sourceId cannot be null");
+        }
+        if (sourceType == null) {
+            throw new IllegalArgumentException("sourceType cannot be null");
+        }
+        if ((destinationPost == null && destinationAnswerPost == null) || (destinationPost != null && destinationAnswerPost != null)) {
+            throw new IllegalArgumentException("Exactly one destination must be non-null");
+        }
+        this.sourceId = sourceId;
+        this.sourceType = sourceType;
+        this.destinationPost = destinationPost;
+        this.destinationAnswerPost = destinationAnswerPost;
+    }
+
+    public long getSourceId() {
+        return sourceId;
+    }
+
+    public void setSourceId(long sourceId) {
+        this.sourceId = sourceId;
+    }
+
+    public PostingType getSourceType() {
+        return sourceType;
+    }
+
+    public void setSourceType(PostingType sourceType) {
+        if (sourceType == null) {
+            throw new IllegalArgumentException("sourceType cannot be null");
+        }
+        this.sourceType = sourceType;
+    }
+
+    public Post getDestinationPost() {
+        return destinationPost;
+    }
+
+    public void setDestinationPost(Post post) {
+        if (post != null && this.destinationAnswerPost != null) {
+            throw new IllegalStateException("Cannot set both destination post and answer post");
+        }
+        this.destinationPost = post;
+    }
+
+    public AnswerPost getDestinationAnswerPost() {
+        return destinationAnswerPost;
+    }
+
+    public void setDestinationAnswerPost(AnswerPost answerPost) {
+        if (answerPost != null && this.destinationPost != null) {
+            throw new IllegalStateException("Cannot set both destination post and answer post");
+        }
+        this.destinationAnswerPost = answerPost;
+    }
+
+}

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

@@ -109,6 +109,9 @@ public class Post extends Posting {
     @Transient
     private boolean isSaved = false;
 
+    @Column(name = "has_forwarded_messages")
+    private boolean hasForwardedMessages;
+
     public Post() {
     }
 
@@ -124,6 +127,14 @@ public void setTitle(String title) {
         this.title = title;
     }
 
+    public boolean getHasForwardedMessages() {
+        return hasForwardedMessages;
+    }
+
+    public void setHasForwardedMessages(boolean hasForwardedMessages) {
+        this.hasForwardedMessages = hasForwardedMessages;
+    }
+
     public Boolean isVisibleForStudents() {
         return visibleForStudents;
     }

src/main/java/de/tum/cit/aet/artemis/communication/dto/ForwardedMessageDTO.java

@@ -0,0 +1,27 @@
+package de.tum.cit.aet.artemis.communication.dto;
+
+import java.util.Optional;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+import de.tum.cit.aet.artemis.communication.domain.AnswerPost;
+import de.tum.cit.aet.artemis.communication.domain.ForwardedMessage;
+import de.tum.cit.aet.artemis.communication.domain.Post;
+import de.tum.cit.aet.artemis.communication.domain.PostingType;
+
+/**
+ * Data Transfer Object for ForwardedMessage.
+ */
+@JsonInclude(JsonInclude.Include.NON_EMPTY)
+public record ForwardedMessageDTO(Long id, Long sourceId, PostingType sourceType, Long destinationPostId, Long destinationAnswerPostId) {
+
+    /**
+     * Constructs a ForwardedMessageDTO from a ForwardedMessage entity.
+     *
+     * @param message the ForwardedMessage entity
+     */
+    public ForwardedMessageDTO(ForwardedMessage message) {
+        this(message.getId(), message.getSourceId(), message.getSourceType(), Optional.ofNullable(message.getDestinationPost()).map(Post::getId).orElse(null),
+                Optional.ofNullable(message.getDestinationAnswerPost()).map(AnswerPost::getId).orElse(null));
+    }
+}

src/main/java/de/tum/cit/aet/artemis/communication/dto/ForwardedMessagesGroupDTO.java

@@ -0,0 +1,13 @@
+package de.tum.cit.aet.artemis.communication.dto;
+
+import java.util.Set;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+/**
+ * Data Transfer Object for grouping Forwarded Messages by ID.
+ */
+@JsonInclude(JsonInclude.Include.NON_EMPTY)
+public record ForwardedMessagesGroupDTO(Long id, Set<ForwardedMessageDTO> messages) {
+
+}

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

@@ -0,0 +1,25 @@
+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.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.stereotype.Repository;
+
+import de.tum.cit.aet.artemis.communication.domain.ForwardedMessage;
+import de.tum.cit.aet.artemis.core.repository.base.ArtemisJpaRepository;
+
+@Profile(PROFILE_CORE)
+@Repository
+public interface ForwardedMessageRepository extends ArtemisJpaRepository<ForwardedMessage, Long> {
+
+    @Query("SELECT fm FROM ForwardedMessage fm WHERE fm.destinationPost.id IN :destinationPostIds")
+    Set<ForwardedMessage> findAllByDestinationPostIds(@Param("destinationPostIds") Set<Long> destinationPostIds);
+
+    @Query("SELECT fm FROM ForwardedMessage fm WHERE fm.destinationAnswerPost.id IN :destinationAnswerPostIds")
+    Set<ForwardedMessage> findAllByDestinationAnswerPostIds(@Param("destinationAnswerPostIds") Set<Long> destinationAnswerPostIds);
+
+}

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

@@ -3,6 +3,7 @@
 import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
 
 import java.time.ZonedDateTime;
+import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
@@ -230,6 +231,10 @@ public AnswerPost findById(Long answerMessageId) {
         return answerPostRepository.findAnswerMessageByIdElseThrow(answerMessageId);
     }
 
+    public List<AnswerPost> findByIdIn(List<Long> answerMessageIds) {
+        return answerPostRepository.findByIdIn(answerMessageIds);
+    }
+
     /**
      * Checks if the requesting user is authorized in the course context,
      * i.e. user has to be the author of original message associated with the answer message or at least teaching assistant

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

@@ -3,6 +3,7 @@
 import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_CORE;
 
 import java.time.ZonedDateTime;
+import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
@@ -40,6 +41,7 @@
 import de.tum.cit.aet.artemis.communication.dto.PostDTO;
 import de.tum.cit.aet.artemis.communication.repository.ConversationMessageRepository;
 import de.tum.cit.aet.artemis.communication.repository.ConversationParticipantRepository;
+import de.tum.cit.aet.artemis.communication.repository.PostRepository;
 import de.tum.cit.aet.artemis.communication.repository.SavedPostRepository;
 import de.tum.cit.aet.artemis.communication.repository.SingleUserNotificationRepository;
 import de.tum.cit.aet.artemis.communication.service.conversation.ConversationService;
@@ -76,11 +78,13 @@ public class ConversationMessagingService extends PostingService {
 
     private final SingleUserNotificationRepository singleUserNotificationRepository;
 
+    private final PostRepository postRepository;
+
     protected ConversationMessagingService(CourseRepository courseRepository, ExerciseRepository exerciseRepository, LectureRepository lectureRepository,
             ConversationMessageRepository conversationMessageRepository, AuthorizationCheckService authorizationCheckService, WebsocketMessagingService websocketMessagingService,
             UserRepository userRepository, ConversationService conversationService, ConversationParticipantRepository conversationParticipantRepository,
             ConversationNotificationService conversationNotificationService, ChannelAuthorizationService channelAuthorizationService, SavedPostRepository savedPostRepository,
-            GroupNotificationService groupNotificationService, SingleUserNotificationRepository singleUserNotificationRepository) {
+            GroupNotificationService groupNotificationService, SingleUserNotificationRepository singleUserNotificationRepository, PostRepository postRepository) {
         super(courseRepository, userRepository, exerciseRepository, lectureRepository, authorizationCheckService, websocketMessagingService, conversationParticipantRepository,
                 savedPostRepository);
         this.conversationService = conversationService;
@@ -89,6 +93,7 @@ protected ConversationMessagingService(CourseRepository courseRepository, Exerci
         this.channelAuthorizationService = channelAuthorizationService;
         this.groupNotificationService = groupNotificationService;
         this.singleUserNotificationRepository = singleUserNotificationRepository;
+        this.postRepository = postRepository;
     }
 
     /**
@@ -409,6 +414,10 @@ public Post changeDisplayPriority(Long courseId, Long postId, DisplayPriority di
         return updatedMessage;
     }
 
+    public List<Post> getMessageByIds(List<Long> sourcePostIds) {
+        return postRepository.findByIdIn(sourcePostIds);
+    }
+
     private Conversation mayUpdateOrDeleteMessageElseThrow(Post existingMessagePost, User user) {
         if (existingMessagePost.getConversation() == null) {
             throw new BadRequestAlertException("The post does not belong to a conversation", METIS_POST_ENTITY_NAME, "conversationnotset");

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

@@ -4,18 +4,21 @@
 
 import java.net.URI;
 import java.net.URISyntaxException;
+import java.util.List;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.context.annotation.Profile;
 import org.springframework.http.HttpStatus;
 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.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 
 import de.tum.cit.aet.artemis.communication.domain.AnswerPost;
@@ -92,4 +95,11 @@ public ResponseEntity<Void> deleteAnswerMessage(@PathVariable Long courseId, @Pa
         // deletion of answerMessages should not trigger alert
         return ResponseEntity.ok().build();
     }
+
+    @GetMapping("courses/{courseId}/answer-messages/source-answer-posts")
+    @EnforceAtLeastStudent
+    public ResponseEntity<List<AnswerPost>> getSourceAnswerPostsByIds(@PathVariable Long courseId, @RequestParam List<Long> answerPostIds) {
+        List<AnswerPost> answerPosts = answerMessageService.findByIdIn(answerPostIds);
+        return ResponseEntity.ok().body(answerPosts);
+    }
 }

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

@@ -203,4 +203,19 @@ public ResponseEntity<Post> updateDisplayPriority(@PathVariable Long courseId, @
         Post postWithUpdatedDisplayPriority = conversationMessagingService.changeDisplayPriority(courseId, postId, displayPriority);
         return ResponseEntity.ok().body(postWithUpdatedDisplayPriority);
     }
+
+    /**
+     * GET /courses/{courseId}/messages/source-posts : Retrieve posts by their IDs
+     *
+     * @param courseId id of the course the posts belong to
+     * @param postIds  list of IDs of the posts to retrieve
+     * @return ResponseEntity with status 200 (OK) containing the list of posts in the response body,
+     *         or with status 400 (Bad Request) if the checks on user, course or post validity fail
+     */
+    @GetMapping("courses/{courseId}/messages/source-posts")
+    @EnforceAtLeastStudent
+    public ResponseEntity<List<Post>> getSourcePostsByIds(@PathVariable Long courseId, @RequestParam List<Long> postIds) {
+        List<Post> posts = conversationMessagingService.getMessageByIds(postIds);
+        return ResponseEntity.ok().body(posts);
+    }
 }