#368 [Merge] v2.0.27 업데이트

src/main/java/com/swyp/picke/domain/perspective/repository/PerspectiveRepository.java

@@ -12,6 +12,10 @@ public interface PerspectiveRepository extends JpaRepository<Perspective, Long>
 
     List<Perspective> findByBattleIdAndUserIdOrderByCreatedAtDesc(Long battleId, Long userId);
 
+    List<Perspective> findByUserIdOrderByCreatedAtDesc(Long userId, Pageable pageable);
+
+    long countByUserId(Long userId);
+
     List<Perspective> findByBattleIdAndStatusOrderByCreatedAtDesc(Long battleId, PerspectiveStatus status, Pageable pageable);
 
     List<Perspective> findByBattleIdAndStatusAndCreatedAtBeforeOrderByCreatedAtDesc(Long battleId, PerspectiveStatus status, LocalDateTime cursor, Pageable pageable);

src/main/java/com/swyp/picke/domain/perspective/service/PerspectiveQueryService.java

@@ -1,9 +1,11 @@
 package com.swyp.picke.domain.perspective.service;
 
+import com.swyp.picke.domain.perspective.entity.Perspective;
 import com.swyp.picke.domain.perspective.entity.PerspectiveComment;
 import com.swyp.picke.domain.perspective.entity.PerspectiveLike;
 import com.swyp.picke.domain.perspective.repository.PerspectiveCommentRepository;
 import com.swyp.picke.domain.perspective.repository.PerspectiveLikeRepository;
+import com.swyp.picke.domain.perspective.repository.PerspectiveRepository;
 import lombok.RequiredArgsConstructor;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.stereotype.Service;
@@ -18,16 +20,26 @@ public class PerspectiveQueryService {
 
     private final PerspectiveCommentRepository perspectiveCommentRepository;
     private final PerspectiveLikeRepository perspectiveLikeRepository;
+    private final PerspectiveRepository perspectiveRepository;
 
-    public List<PerspectiveComment> findUserComments(Long userId, int offset, int size) {
-        PageRequest pageable = PageRequest.of(offset / size, size);
+    public List<PerspectiveComment> findUserComments(Long userId, int limit) {
+        PageRequest pageable = PageRequest.of(0, limit);
         return perspectiveCommentRepository.findByUserIdOrderByCreatedAtDesc(userId, pageable);
     }
 
     public long countUserComments(Long userId) {
         return perspectiveCommentRepository.countByUserId(userId);
     }
 
+    public List<Perspective> findUserPerspectives(Long userId, int limit) {
+        PageRequest pageable = PageRequest.of(0, limit);
+        return perspectiveRepository.findByUserIdOrderByCreatedAtDesc(userId, pageable);
+    }
+
+    public long countUserPerspectives(Long userId) {
+        return perspectiveRepository.countByUserId(userId);
+    }
+
     public List<PerspectiveLike> findUserLikes(Long userId, int offset, int size) {
         PageRequest pageable = PageRequest.of(offset / size, size);
         return perspectiveLikeRepository.findByUserIdOrderByCreatedAtDesc(userId, pageable);

src/main/java/com/swyp/picke/domain/user/enums/ActivityType.java

@@ -2,5 +2,6 @@
 
 public enum ActivityType {
     COMMENT,
-    LIKE
+    LIKE,
+    PERSPECTIVE
 }

src/main/java/com/swyp/picke/domain/user/service/MypageService.java

@@ -33,7 +33,9 @@
 
 import java.time.LocalDateTime;
 import java.util.ArrayList;
+import java.util.Comparator;
 import java.util.List;
+import java.util.stream.Stream;
 import java.util.Map;
 
 @Service
@@ -190,25 +192,40 @@ public ContentActivityListResponse getContentActivities(Integer offset, Integer
     }
 
     private ContentActivityListResponse buildCommentActivities(User user, int pageOffset, int pageSize) {
-        List<PerspectiveComment> comments = perspectiveQueryService.findUserComments(user.getId(), pageOffset, pageSize);
-        long totalCount = perspectiveQueryService.countUserComments(user.getId());
+        int limit = pageOffset + pageSize;
+
+        List<PerspectiveComment> comments = perspectiveQueryService.findUserComments(user.getId(), limit);
+        List<Perspective> myPerspectives = perspectiveQueryService.findUserPerspectives(user.getId(), limit);
 
         UserProfile profile = userService.findUserProfile(user.getId());
         String myCharacterImageUrl = resolveCharacterImageUrl(profile.getCharacterType());
 
-        List<Perspective> perspectives = comments.stream().map(PerspectiveComment::getPerspective).toList();
-        Map<Long, Battle> battleMap = loadBattles(perspectives);
-        Map<Long, BattleOption> optionMap = loadOptions(perspectives);
+        List<Perspective> lookupTargets = new ArrayList<>(comments.stream().map(PerspectiveComment::getPerspective).toList());
+        lookupTargets.addAll(myPerspectives);
+        Map<Long, Battle> battleMap = loadBattles(lookupTargets);
+        Map<Long, BattleOption> optionMap = loadOptions(lookupTargets);
 
-        List<ContentActivityListResponse.ContentActivityItem> items = comments.stream()
+        Stream<ContentActivityListResponse.ContentActivityItem> commentItems = comments.stream()
                 .map(comment -> {
                     Perspective p = comment.getPerspective();
                     return toActivityItem(comment.getId().toString(), ActivityType.COMMENT, p,
                             battleMap.get(p.getBattle().getId()), optionMap.get(p.getOption().getId()),
                             comment.getContent(), comment.getCreatedAt(), myCharacterImageUrl);
-                })
+                });
+
+        Stream<ContentActivityListResponse.ContentActivityItem> perspectiveItems = myPerspectives.stream()
+                .map(p -> toActivityItem(p.getId().toString(), ActivityType.PERSPECTIVE, p,
+                        battleMap.get(p.getBattle().getId()), optionMap.get(p.getOption().getId()),
+                        p.getContent(), p.getCreatedAt(), myCharacterImageUrl));
+
+        List<ContentActivityListResponse.ContentActivityItem> items = Stream.concat(commentItems, perspectiveItems)
+                .sorted(Comparator.comparing(ContentActivityListResponse.ContentActivityItem::createdAt).reversed())
+                .skip(pageOffset)
+                .limit(pageSize)
                 .toList();
 
+        long totalCount = perspectiveQueryService.countUserComments(user.getId())
+                + perspectiveQueryService.countUserPerspectives(user.getId());
         int nextOffset = pageOffset + pageSize;
         boolean hasNext = nextOffset < totalCount;
         return new ContentActivityListResponse(items, hasNext ? nextOffset : null, hasNext);

src/test/java/com/swyp/picke/domain/user/service/MypageServiceTest.java

@@ -248,8 +248,10 @@ void getContentActivities_returns_comments() {
 
         when(userService.findCurrentUser()).thenReturn(user);
         when(userService.findUserProfile(1L)).thenReturn(profile);
-        when(perspectiveQueryService.findUserComments(1L, 0, 20)).thenReturn(List.of(comment));
+        when(perspectiveQueryService.findUserComments(1L, 20)).thenReturn(List.of(comment));
+        when(perspectiveQueryService.findUserPerspectives(1L, 20)).thenReturn(List.of());
         when(perspectiveQueryService.countUserComments(1L)).thenReturn(1L);
+        when(perspectiveQueryService.countUserPerspectives(1L)).thenReturn(0L);
         when(battleQueryService.findBattlesByIds(List.of(battleId))).thenReturn(Map.of(battleId, battle));
         when(battleQueryService.findOptionsByIds(List.of(optionId))).thenReturn(Map.of(optionId, option));
         when(userService.findSummaryById(1L)).thenReturn(new UserSummary("tag", "nick", "OWL"));
@@ -261,6 +263,60 @@ void getContentActivities_returns_comments() {
         assertThat(response.items().get(0).content()).isEqualTo("댓글");
     }
 
+    @Test
+    @DisplayName("COMMENT 타입으로 조회하면 내가 작성한 관점과 댓글이 최신순으로 병합되어 반환된다")
+    void getContentActivities_merges_perspectives_and_comments_by_created_at() {
+        User user = createUser(1L, "tag");
+        UserProfile profile = createProfile(user, "nick", CharacterType.OWL);
+        Battle battle = createBattle("배틀");
+        Long battleId = battle.getId();
+        BattleOption option = createOption(battle, BattleOptionLabel.A);
+        Long optionId = option.getId();
+
+        Perspective myPerspective = Perspective.builder()
+                .battle(battle)
+                .user(user)
+                .option(option)
+                .content("내가 쓴 관점")
+                .build();
+        ReflectionTestUtils.setField(myPerspective, "id", generateId());
+        ReflectionTestUtils.setField(myPerspective, "createdAt", LocalDateTime.now());
+
+        Perspective othersPerspective = Perspective.builder()
+                .battle(battle)
+                .user(user)
+                .option(option)
+                .content("다른 사람 관점")
+                .build();
+        ReflectionTestUtils.setField(othersPerspective, "id", generateId());
+
+        PerspectiveComment comment = PerspectiveComment.builder()
+                .perspective(othersPerspective)
+                .user(user)
+                .content("내가 남긴 댓글")
+                .build();
+        ReflectionTestUtils.setField(comment, "id", generateId());
+        ReflectionTestUtils.setField(comment, "createdAt", LocalDateTime.now().minusMinutes(1));
+
+        when(userService.findCurrentUser()).thenReturn(user);
+        when(userService.findUserProfile(1L)).thenReturn(profile);
+        when(perspectiveQueryService.findUserComments(1L, 20)).thenReturn(List.of(comment));
+        when(perspectiveQueryService.findUserPerspectives(1L, 20)).thenReturn(List.of(myPerspective));
+        when(perspectiveQueryService.countUserComments(1L)).thenReturn(1L);
+        when(perspectiveQueryService.countUserPerspectives(1L)).thenReturn(1L);
+        when(battleQueryService.findBattlesByIds(List.of(battleId))).thenReturn(Map.of(battleId, battle));
+        when(battleQueryService.findOptionsByIds(List.of(optionId))).thenReturn(Map.of(optionId, option));
+        when(userService.findSummaryById(1L)).thenReturn(new UserSummary("tag", "nick", "OWL"));
+
+        ContentActivityListResponse response = mypageService.getContentActivities(null, null, ActivityType.COMMENT);
+
+        assertThat(response.items()).hasSize(2);
+        assertThat(response.items().get(0).activityType()).isEqualTo(ActivityType.PERSPECTIVE);
+        assertThat(response.items().get(0).content()).isEqualTo("내가 쓴 관점");
+        assertThat(response.items().get(1).activityType()).isEqualTo(ActivityType.COMMENT);
+        assertThat(response.items().get(1).content()).isEqualTo("내가 남긴 댓글");
+    }
+
     @Test
     @DisplayName("LIKE 타입으로 좋아요활동을 반환한다")
     void getContentActivities_returns_likes() {