Merge pull request #129 from Me1tingPot/feature/#39

✨ [Feature] Comment페이지네이션

src/main/java/meltingpot/server/comment/controller/CommentController.java

@@ -50,6 +50,19 @@ public ResponseEntity<ResponseData<CommentResponseDTO.CreateCommentResultDTO>> u
         }
     }
 
+    @Operation(summary = "댓글 목록 가져오기")
+    @GetMapping("/list/{postId}")
+    public ResponseEntity<ResponseData<CommentResponseDTO.CommentsListDTO>> getCommentsList ( @CurrentUser Account account, @PathVariable Long postId,
+                                                                                              @RequestParam(required = false) Long cursor,
+                                                                                              @RequestParam(defaultValue = "10") int pageSize){
+        try{
+            return ResponseData.toResponseEntity(ResponseCode.READ_COMMENTS_LIST_SUCCESS, commentService.getCommentsList(account,postId,cursor,pageSize));
+        }catch (NoSuchElementException e) {
+            return ResponseData.toResponseEntity(ResponseCode.COMMENT_UPDATE_FAIL, null);
+        }
+    }
+
+
 }
 
 

src/main/java/meltingpot/server/comment/converter/CommentConverter.java

@@ -8,6 +8,7 @@
 import meltingpot.server.domain.entity.post.Post;
 
 import java.util.List;
+import java.util.stream.Collectors;
 
 @RequiredArgsConstructor
 public class CommentConverter {
@@ -38,22 +39,25 @@ public static CommentResponseDTO.CreateCommentResultDTO toCreateCommentResult(St
     public static CommentResponseDTO.CommentDetailDTO toCommentDetailDTO(Comment comment){
         return CommentResponseDTO.CommentDetailDTO.builder()
                 .commentId(comment.getId())
+                .parentId(comment.getParent() != null ? comment.getParent().getId() : null)
+                .userId(comment.getAccount().getId())
                 .content(comment.getContent())
                 .name(comment.getAccount().getName())
+                .isAnonymous(comment.getIsAnonymous())
                 .updatedAt(comment.getUpdatedAt())
+                .children(comment.getChildren() != null ? toCommentDetailDTOList(comment.getChildren()) : null)
                 .build();
     }
 
-    public static CommentResponseDTO.ParentCommentDTO toParentCommentDTO(Comment parentComment,List<CommentResponseDTO.CommentDetailDTO>childrenComments){
-        return CommentResponseDTO.ParentCommentDTO.builder()
-                .parentComment(toCommentDetailDTO(parentComment))
-                .childrenComments(childrenComments)
-                .build();
+    public static List<CommentResponseDTO.CommentDetailDTO> toCommentDetailDTOList(List<Comment> comments) {
+        return comments.stream()
+                .map(CommentConverter::toCommentDetailDTO)
+                .collect(Collectors.toList());
     }
 
-    public static CommentResponseDTO.CommentsListDTO toCommentsListDTO(List<CommentResponseDTO.ParentCommentDTO> parentComments, Long nextCursor, Boolean isLast){
+    public static CommentResponseDTO.CommentsListDTO toCommentsListDTO(List<CommentResponseDTO.CommentDetailDTO> comments, Long nextCursor, Boolean isLast){
         return CommentResponseDTO.CommentsListDTO.builder()
-                .parentComments(parentComments)
+                .comments(comments)
                 .nextCursor(nextCursor)
                 .isLast(isLast)
                 .build();

src/main/java/meltingpot/server/comment/dto/CommentResponseDTO.java

@@ -1,6 +1,7 @@
 package meltingpot.server.comment.dto;
 
 import lombok.*;
+import meltingpot.server.domain.entity.comment.Comment;
 
 import java.time.LocalDateTime;
 import java.util.List;
@@ -25,32 +26,36 @@ public static class CreateCommentResultDTO{
     @AllArgsConstructor(access = AccessLevel.PROTECTED)
     public static class CommentDetailDTO {
         private Long commentId;
+        private Long parentId;
+        private Long userId;
         private String content;
         private String name;
         private Boolean isAnonymous;
         private String imageUrl;
         private LocalDateTime updatedAt;
+        private List<CommentDetailDTO> children;
     }
 
 
-    @Builder
-    @Getter
-    @Setter
-    @NoArgsConstructor(access = AccessLevel.PROTECTED)
-    @AllArgsConstructor(access = AccessLevel.PROTECTED)
-    public static class ParentCommentDTO{
-        private CommentDetailDTO parentComment;
-        private List<CommentDetailDTO> childrenComments;
-    }
 
     @Builder
     @Getter
     @NoArgsConstructor(access = AccessLevel.PROTECTED)
     @AllArgsConstructor(access = AccessLevel.PROTECTED)
     public static class CommentsListDTO{
-        private List<ParentCommentDTO> parentComments;
+        private List<CommentDetailDTO> comments;
         private Long nextCursor;
         private Boolean isLast;
     }
 
+    public  class CommentQueueItem {
+        public Comment parent;
+        public List<Comment> children;
+
+        public CommentQueueItem(Comment parent, List<Comment> children) {
+            this.parent = parent;
+            this.children = children;
+        }
+    }
+
 }

src/main/java/meltingpot/server/comment/service/CommentService.java

@@ -11,4 +11,6 @@ public interface CommentService {
     CommentResponseDTO.CreateCommentResultDTO createChildComment  (CommentRequestDTO.CreateCommentDTO createCommentDTO, Account account, Long commentId);
 
     CommentResponseDTO.CreateCommentResultDTO updateComment (CommentRequestDTO.CreateCommentDTO updateCommentDTO,Account account, Long commentId);
+
+    CommentResponseDTO.CommentsListDTO getCommentsList(Account account, Long postId, Long cursor, int pageSize);
 }

src/main/java/meltingpot/server/comment/service/CommentServiceImpl.java

@@ -13,16 +13,16 @@
 import meltingpot.server.domain.repository.CommentRepository;
 import meltingpot.server.domain.repository.PostRepository;
 import meltingpot.server.util.r2.FileService;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.util.List;
-import java.util.Collections;
+import java.util.*;
 import java.util.stream.Collectors;
 
-import static meltingpot.server.comment.converter.CommentConverter.toComment;
-import static meltingpot.server.comment.converter.CommentConverter.toCreateCommentResult;
+import static meltingpot.server.comment.converter.CommentConverter.*;
 import static meltingpot.server.comment.converter.CommentImageConverter.toCommentImage;
 
 @Service
@@ -38,8 +38,7 @@ public class CommentServiceImpl implements CommentService {
 
 
     @Override
-    //
-    public CommentResponseDTO.CreateCommentResultDTO createComment (CommentRequestDTO.CreateCommentDTO createCommentDTO, Account account, Long postId) {
+    public CommentResponseDTO.CreateCommentResultDTO createComment(CommentRequestDTO.CreateCommentDTO createCommentDTO, Account account, Long postId) {
         Post post = findPostById(postId);
         Comment comment = toComment(createCommentDTO, account, post);
         return processCommentCreation(createCommentDTO, account, comment);
@@ -52,58 +51,92 @@ public CommentResponseDTO.CreateCommentResultDTO createChildComment(CommentReque
         return processCommentCreation(createCommentDTO, account, childComment);
     }
 
-//    @Override
-//    public CommentResponseDTO.CreateCommentResultDTO updateComment (CommentRequestDTO.CreateCommentDTO updateCommentDTO, Account account,Long commentId){
-//        Comment comment = findCommentById(commentId);
-//        Post post = comment.getPost();
-//        String newImageKey = updateCommentDTO.getImageKey();
-//        CommentImage oldCommentImage = comment.getCommentImage();
-//        if (newImageKey == null || newImageKey.isEmpty()) {
-//            if (oldCommentImage != null) {
-//                commentImageRepository.delete(oldCommentImage);
-//                comment.setCommentImage(null);
-//            }
-//        } else {
-//            comment = toComment(updateCommentDTO,account,post);
-//        }
-//        return processCommentCreation(updateCommentDTO, account, comment);
-//    }
-@Override
-public CommentResponseDTO.CreateCommentResultDTO updateComment(CommentRequestDTO.CreateCommentDTO updateCommentDTO, Account account, Long commentId) {
-    // 댓글을 ID로 찾기
-    Comment comment = findCommentById(commentId);
-
-    // 댓글 내용 업데이트
-    comment.setContent(updateCommentDTO.getContent());
-
-    // 새로운 이미지 키와 기존 댓글 이미지 가져오기
-    String newImageKey = updateCommentDTO.getImageKey();
-    CommentImage oldCommentImage = comment.getCommentImage();
-
-    if (newImageKey == null || newImageKey.isEmpty()) {
-        // 새로운 이미지 키가 없을 경우 기존 이미지 삭제
-        if (oldCommentImage != null) {
-            commentImageRepository.delete(oldCommentImage);
-            comment.setCommentImage(null);
-        }
-    } else {
-        // 새로운 이미지 키가 있을 경우 이미지 업데이트 또는 생성
-        if (oldCommentImage != null) {
-            oldCommentImage.setImageKey(newImageKey);
-            commentImageRepository.save(oldCommentImage);
+    @Override
+    public CommentResponseDTO.CreateCommentResultDTO updateComment(CommentRequestDTO.CreateCommentDTO updateCommentDTO, Account account, Long commentId) {
+        // 댓글을 ID로 찾기
+        Comment comment = findCommentById(commentId);
+
+        // 댓글 내용 업데이트
+        comment.setContent(updateCommentDTO.getContent());
+
+        // 새로운 이미지 키와 기존 댓글 이미지 가져오기
+        String newImageKey = updateCommentDTO.getImageKey();
+        CommentImage oldCommentImage = comment.getCommentImage();
+
+        if (newImageKey == null || newImageKey.isEmpty()) {
+            // 새로운 이미지 키가 없을 경우 기존 이미지 삭제
+            if (oldCommentImage != null) {
+                commentImageRepository.delete(oldCommentImage);
+                comment.setCommentImage(null);
+            }
         } else {
-            CommentImage newCommentImage = toCommentImage(updateCommentDTO, account, comment);
-            comment.setCommentImage(newCommentImage);
+            // 새로운 이미지 키가 있을 경우 이미지 업데이트 또는 생성
+            if (oldCommentImage != null) {
+                oldCommentImage.setImageKey(newImageKey);
+                commentImageRepository.save(oldCommentImage);
+            } else {
+                CommentImage newCommentImage = toCommentImage(updateCommentDTO, account, comment);
+                comment.setCommentImage(newCommentImage);
+            }
         }
+
+
+        // 댓글 저장
+        commentRepository.save(comment);
+
+        // 결과 DTO 생성 및 반환
+        String commentImgUrl = newImageKey != null && !newImageKey.isEmpty() ? fileService.getCdnUrl("comment", newImageKey) : null;
+        return toCreateCommentResult(commentImgUrl, comment);
     }
 
-    // 댓글 저장
-    commentRepository.save(comment);
 
-    // 결과 DTO 생성 및 반환
-    String commentImgUrl = newImageKey != null && !newImageKey.isEmpty() ? fileService.getCdnUrl("comment", newImageKey) : null;
-    return toCreateCommentResult(commentImgUrl, comment);
-}
+    public CommentResponseDTO.CommentsListDTO getCommentsList(Account account, Long postId, Long cursor, int pageSize) {
+        // Retrieve the parent comment based on cursor
+        Comment parentComment = getParentComment(cursor, postId);
+
+        // If no parent comment found, throw an exception or handle accordingly
+        if (parentComment == null) {
+            throw new NoSuchElementException("No parent comment found for the given cursor.");
+        }
+
+        // Retrieve child comments for the parent comment
+        List<Comment> childComments = getChildComments(parentComment, pageSize - 1); // -1 for the parent comment
+
+        // Determine the next cursor and if it's the last page
+        Long nextCursor = determineNextCursor(parentComment, childComments, pageSize);
+        boolean isLast = nextCursor == null;
+
+        // Convert parent comment to DTO
+        CommentResponseDTO.CommentDetailDTO parentCommentDTO = CommentConverter.toCommentDetailDTO(parentComment);
+
+        // Convert child comments to DTOs
+        List<CommentResponseDTO.CommentDetailDTO> childCommentDTOs = CommentConverter.toCommentDetailDTOList(childComments);
+
+        // Add the parent comment DTO at the beginning of the list
+        childCommentDTOs.add(0, parentCommentDTO);
+
+        // Return the final DTO list with next cursor and isLast flag
+        return CommentResponseDTO.CommentsListDTO.builder()
+                .comments(childCommentDTOs)
+                .nextCursor(nextCursor)
+                .isLast(isLast)
+                .build();
+    }
+
+
+    private Comment getParentComment(Long cursor, Long postId) {
+        if (cursor == null) {
+            // Fetch the first parent comment if no cursor is provided
+            return commentRepository.findFirstByPostIdAndParentIsNull(postId).orElse(null);
+        } else {
+            // Fetch the parent comment based on the cursor
+            return commentRepository.findById(cursor).orElse(null);
+        }
+    }
+
+    private List<Comment> getChildComments(Comment parentComment, int pageSize) {
+        return commentRepository.findByParent(parentComment, PageRequest.of(0, pageSize));
+    }
 
     private CommentResponseDTO.CreateCommentResultDTO processCommentCreation(CommentRequestDTO.CreateCommentDTO createCommentDTO, Account account, Comment comment) {
         String commentImgUrl = null;
@@ -120,7 +153,7 @@ private CommentResponseDTO.CreateCommentResultDTO processCommentCreation(Comment
 
     private Comment findCommentById(Long commentId) {
         return commentRepository.findById(commentId)
-                .orElseThrow(() ->  new RuntimeException("댓글을 찾을 수 없습니다."));
+                .orElseThrow(() -> new RuntimeException("댓글을 찾을 수 없습니다."));
     }
 
 
@@ -134,4 +167,17 @@ private Post findPostById(Long postId) {
                 .orElseThrow(() -> new RuntimeException("게시물을 찾을 수 없습니다."));
     }
 
+    private Long determineNextCursor(Comment parentComment, List<Comment> childComments, int pageSize) {
+        if (childComments.size() < pageSize - 1) {
+            // 자식 댓글의 수가 페이지 크기보다 적으면, 다음 부모 댓글을 가져온다.
+            Optional<Comment> nextParentComment = commentRepository.findNextParentComment(parentComment.getId(), parentComment.getPost().getId());
+            return nextParentComment.map(Comment::getId).orElse(null);
+        } else {
+            // 마지막으로 가져온 자식 댓글의 ID를 다음 커서로 설정한다.
+            return childComments.get(childComments.size() - 1).getId();
+        }
+    }
 }
+
+
+

src/main/java/meltingpot/server/domain/entity/comment/Comment.java

@@ -2,6 +2,7 @@
 
 import jakarta.persistence.*;
 import lombok.*;
+import meltingpot.server.comment.dto.CommentResponseDTO;
 import meltingpot.server.domain.entity.Account;
 import meltingpot.server.domain.entity.post.Post;
 import meltingpot.server.domain.entity.common.BaseEntity;
@@ -77,4 +78,11 @@ public CommentImage getCommentImage() {
     public void setContent(String content) {
         this.content = content;
     }
+
+    public Comment getParent() { return parent;}
+
+
+    public List<Comment> getChildren() {
+        return children;
+    }
 }

src/main/java/meltingpot/server/domain/entity/post/Post.java

@@ -48,6 +48,10 @@ public class Post extends BaseEntity {
     @OneToMany(mappedBy = "post")
     private List<Report> reports = new ArrayList<>();
 
+    public List<PostImage> getPostImages() {
+        return postImages;
+    }
+
     public void setPostImages(List<PostImage> postImages) {
         this.postImages = postImages.stream()
                 .map(postImage -> {

src/main/java/meltingpot/server/domain/repository/CommentRepository.java

@@ -19,12 +19,22 @@ public interface CommentRepository extends JpaRepository<Comment, Long> {
 
     Optional<Comment> findById(Long id);
 
-    @Query("SELECT c FROM Comment c WHERE c.post.id = :postId AND c.parent IS NULL AND c.id < :cursor ORDER BY c.id DESC")
-    List<Comment> findParentCommentsByPostIdAndCursor(@Param("postId") Long postId, @Param("cursor") Long cursor, Pageable pageable);
+    @Query("SELECT c FROM Comment c WHERE c.post.id = :postId AND c.id < :cursor ORDER BY c.id DESC")
+    List<Comment> findParentComments(Long postId, Long cursor, Pageable pageable);
 
-        @Query("SELECT c FROM Comment c WHERE c.parent.id = :parentId ORDER BY c.id ASC")
-        List<Comment> findChildCommentsByParentId(@Param("parentId") Long parentId, Pageable pageable);
+    // 자식 댓글을 조회하는 메서드
+    @Query("SELECT c FROM Comment c WHERE c.parent.id = :parentId")
+    List<Comment> findChildrenComments(Long parentId);
 
+    // 부모가 없는 첫 번째 댓글을 찾기 위한 메서드 (가장 상위 댓글)
+    Optional<Comment> findFirstByPostIdAndParentIsNull(Long postId);
+
+    // 특정 부모 댓글의 자식 댓글을 페이지로 가져오는 메서드
+    List<Comment> findByParent(Comment parent, Pageable pageable);
+
+    // 다음 부모 댓글을 찾기 위한 메서드
+    @Query("SELECT c FROM Comment c WHERE c.post.id = :postId AND c.parent IS NULL AND c.id > :parentId ORDER BY c.id ASC")
+    Optional<Comment> findNextParentComment(Long parentId, Long postId);
 
     Slice<Comment> findAllByAccountAndDeletedAtIsNullOrderByIdDesc(Account account, Pageable pageable);
 }