feat: 마이페이지 구현

src/main/java/com/cheeeese/album/application/AlbumQueryService.java

@@ -0,0 +1,187 @@
+package com.cheeeese.album.application;
+
+import com.cheeeese.album.domain.Album;
+import com.cheeeese.album.domain.type.Role;
+import com.cheeeese.album.dto.response.ClosedAlbumPageResponse;
+import com.cheeeese.album.dto.response.ClosedAlbumSummaryResponse;
+import com.cheeeese.album.dto.response.OpenAlbumPageResponse;
+import com.cheeeese.album.dto.response.OpenAlbumSummaryResponse;
+import com.cheeeese.album.infrastructure.mapper.AlbumQueryMapper;
+import com.cheeeese.album.infrastructure.persistence.UserAlbumRepository;
+import com.cheeeese.cheese4cut.domain.Cheese4cutPhoto;
+import com.cheeeese.cheese4cut.infrastructure.persistence.Cheese4cutPhotoRepository;
+import com.cheeeese.global.util.resolver.CdnUrlResolver;
+import com.cheeeese.photo.domain.Photo;
+import com.cheeeese.photo.domain.PhotoStatus;
+import com.cheeeese.photo.infrastructure.persistence.PhotoRepository;
+import com.cheeeese.user.domain.User;
+import com.cheeeese.user.exception.UserException;
+import com.cheeeese.user.exception.code.UserErrorCode;
+import com.cheeeese.user.infrastructure.persistence.UserRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Slice;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+public class AlbumQueryService {
+
+    private static final int RECENT_THUMBNAIL_COUNT = 3;
+
+    private final UserAlbumRepository userAlbumRepository;
+    private final UserRepository userRepository;
+    private final PhotoRepository photoRepository;
+    private final Cheese4cutPhotoRepository cheese4cutPhotoRepository;
+    private final CdnUrlResolver cdnUrlResolver;
+
+    public OpenAlbumPageResponse getOpenAlbums(User user, int page, int size) {
+        Pageable pageable = PageRequest.of(page, size);
+
+        Slice<Album> albums = userAlbumRepository.findOpenAlbumsByUserId(
+                user.getId(),
+                Album.AlbumStatus.ACTIVE,
+                LocalDateTime.now(),
+                pageable
+        );
+
+        List<OpenAlbumSummaryResponse> responses = buildOpenAlbumResponses(albums.getContent());
+
+        return AlbumQueryMapper.toOpenAlbumPageResponse(responses, albums);
+    }
+
+    public OpenAlbumPageResponse getMyOpenAlbums(User user, int page, int size) {
+        Pageable pageable = PageRequest.of(page, size);
+        Slice<Album> albums = userAlbumRepository.findOpenAlbumsByUserIdAndRole(
+                user.getId(),
+                Role.MAKER,
+                Album.AlbumStatus.ACTIVE,
+                LocalDateTime.now(),
+                pageable
+        );
+
+        List<OpenAlbumSummaryResponse> responses = buildOpenAlbumResponses(albums.getContent());
+
+        return AlbumQueryMapper.toOpenAlbumPageResponse(responses, albums);
+    }
+
+    public ClosedAlbumPageResponse getClosedAlbums(User user, int page, int size) {
+        Pageable pageable = PageRequest.of(page, size);
+
+        Slice<Album> expiredAlbums = userAlbumRepository.findClosedAlbumsByUserId(
+                user.getId(),
+                Album.AlbumStatus.EXPIRED,
+                pageable
+        );
+
+        List<Long> albumIds = expiredAlbums.getContent().stream()
+                .map(Album::getId)
+                .toList();
+
+        if (albumIds.isEmpty()) {
+            return AlbumQueryMapper.toClosedAlbumPageResponse(List.of(), expiredAlbums);
+        }
+
+        Map<Long, User> makerMap = getMakers(expiredAlbums.getContent());
+
+        List<Cheese4cutPhoto> allCheese4cutPhotos = cheese4cutPhotoRepository.findAllCheese4cutPhotosByAlbumIds(albumIds);
+
+        Map<Long, List<Cheese4cutPhoto>> cheese4cutPhotoMap = allCheese4cutPhotos.stream()
+                .collect(Collectors.groupingBy(
+                        c4p -> c4p.getCheese4cut().getAlbum().getId(),
+                        Collectors.toList()
+                ));
+
+        List<ClosedAlbumSummaryResponse> responses = expiredAlbums.getContent().stream()
+                .map(album -> {
+                    List<Cheese4cutPhoto> c4pList = cheese4cutPhotoMap.getOrDefault(album.getId(), List.of());
+
+                    User maker = Optional.ofNullable(makerMap.get(album.getMakerId()))
+                            .orElseThrow(() -> new UserException(UserErrorCode.USER_NOT_FOUND));
+
+                    List<String> thumbnails = c4pList.stream()
+                            .sorted(Comparator.comparingInt(Cheese4cutPhoto::getPhotoRank)) // photoRank 순으로 정렬
+                            .map(Cheese4cutPhoto::getThumbnailImageUrl)
+                            .map(cdnUrlResolver::resolveThumbnail)
+                            .collect(Collectors.toList());
+
+                    return AlbumQueryMapper.toClosedAlbumSummaryResponse(album, maker, thumbnails);
+                })
+                .collect(Collectors.toList());
+
+        return AlbumQueryMapper.toClosedAlbumPageResponse(responses, expiredAlbums);
+    }
+
+    private List<OpenAlbumSummaryResponse> buildOpenAlbumResponses(List<Album> albums) {
+        if (albums.isEmpty()) {
+            return List.of();
+        }
+
+        Map<Long, User> makerMap = getMakers(albums);
+        Map<Long, List<String>> recentThumbnailsMap = getRecentThumbnailsMap(albums);
+
+        return albums.stream()
+                .map(album -> {
+                    User maker = Optional.ofNullable(makerMap.get(album.getMakerId()))
+                            .orElseThrow(() -> new UserException(UserErrorCode.USER_NOT_FOUND));
+
+                    List<String> recentThumbnails = recentThumbnailsMap.getOrDefault(album.getId(), List.of());
+                    return AlbumQueryMapper.toOpenAlbumSummaryResponse(album, maker, recentThumbnails);
+                })
+                .toList();
+    }
+
+    private Map<Long, User> getMakers(List<Album> albums) {
+        List<Long> makerIds = albums.stream()
+                .map(Album::getMakerId)
+                .distinct()
+                .toList();
+        Map<Long, User> makers = userRepository.findAllById(makerIds).stream()
+                .collect(Collectors.toMap(User::getId, Function.identity()));
+        if (makers.size() != makerIds.size()) {
+            throw new UserException(UserErrorCode.USER_NOT_FOUND);
+        }
+        return makers;
+    }
+
+    private Map<Long, List<String>> getRecentThumbnailsMap(List<Album> albums) {
+        List<Long> albumIds = albums.stream()
+                .map(Album::getId)
+                .toList();
+
+        if (albumIds.isEmpty()) {
+            return Map.of();
+        }
+
+        List<Photo> photos = photoRepository.findTop3RecentPhotosInEachAlbum(
+                albumIds,
+                PhotoStatus.COMPLETED
+        );
+
+        Map<Long, List<String>> thumbnailsMap = new HashMap<>();
+
+        for (Photo photo : photos) {
+            Long albumId = photo.getAlbum().getId();
+            List<String> thumbnails = thumbnailsMap.computeIfAbsent(albumId, key -> new ArrayList<>());
+
+            if (thumbnails.size() < RECENT_THUMBNAIL_COUNT) {
+                thumbnails.add(cdnUrlResolver.resolveThumbnail(photo.getThumbnailUrl()));
+            }
+        }
+
+        return thumbnailsMap.entrySet().stream()
+                .filter(entry -> entry.getValue().size() == RECENT_THUMBNAIL_COUNT)
+                .collect(Collectors.toMap(
+                        Map.Entry::getKey,
+                        entry -> List.copyOf(entry.getValue())
+                ));
+    }
+}

src/main/java/com/cheeeese/album/dto/request/AlbumCreationRequest.java

@@ -6,7 +6,15 @@
 import java.time.LocalDate;
 
 @Builder
-@Schema(description = "앨범 생성 API")
+@Schema(
+        description = "앨범 생성 요청",
+        requiredProperties = {
+                "themeEmoji",
+                "title",
+                "participant",
+                "eventDate"
+        }
+)
 public record AlbumCreationRequest(
         @Schema(description = "앨범 테마 이모지", example = "U+1F9C0")
         String themeEmoji,

src/main/java/com/cheeeese/album/dto/response/AlbumCreationResponse.java

@@ -6,8 +6,16 @@
 import java.time.LocalDate;
 
 @Builder
-@Schema(description = "앨범 생성 API")
-public record AlbumCreationResponse(
+@Schema(
+        description = "앨범 생성 응답",
+        requiredProperties = {
+                "themeEmoji",
+                "title",
+                "eventDate",
+                "currentPhotoCnt",
+                "code"
+        }
+)public record AlbumCreationResponse(
         @Schema(description = "앨범 테마 이모지", example = "U+1F9C0")
         String themeEmoji,
 

src/main/java/com/cheeeese/album/dto/response/AlbumInvitationResponse.java

@@ -6,8 +6,18 @@
 import java.time.LocalDateTime;
 
 @Builder
-@Schema(description = "앨범 초대장 확인 응답 DTO")
-public record AlbumInvitationResponse(
+@Schema(
+        description = "앨범 초대장 확인 응답 DTO",
+        requiredProperties = {
+                "title",
+                "themeEmoji",
+                "eventDate",
+                "expiredAt",
+                "makerName",
+                "makerProfileImage",
+                "isExpired"
+        }
+)public record AlbumInvitationResponse(
         @Schema(description = "앨범 제목", example = "경영학부 졸업식")
         String title,
 

src/main/java/com/cheeeese/album/dto/response/AlbumMakerInfo.java

@@ -3,7 +3,13 @@
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Builder;
 
-@Schema(description = "앨범 메이커 정보 응답 DTO")
+@Schema(
+        description = "앨범 메이커 정보 응답 DTO",
+        requiredProperties = {
+                "makerName",
+                "makerProfileImage"
+        }
+)
 @Builder
 public record AlbumMakerInfo(
         @Schema(description = "메이커 이름", example = "우다현")

src/main/java/com/cheeeese/album/dto/response/AlbumParticipantListResponse.java

@@ -7,13 +7,26 @@
 import java.util.List;
 
 @Builder
-@Schema(description = "앨범 참여자 공통 정보 구조")
+@Schema(
+        description = "앨범 참여자 공통 정보 구조",
+        requiredProperties = {
+                "participants"
+        }
+)
 public record AlbumParticipantListResponse(
         @Schema(description = "참가자 목록 (정렬 포함)")
         List<ParticipantInfo> participants
 ) {
     @Builder
-    @Schema(description = "참가자 개별 정보")
+    @Schema(
+            description = "참가자 개별 정보",
+            requiredProperties = {
+                    "name",
+                    "profileImage",
+                    "role",
+                    "isMe"
+            }
+    )
     public record ParticipantInfo(
             @Schema(description = "이름", example = "우다현")
             String name,

src/main/java/com/cheeeese/album/dto/response/AlbumParticipantResponse.java

@@ -9,7 +9,19 @@
 import java.util.List;
 
 @Builder
-@Schema(description = "앨범 참여자 목록 응답 DTO (활성/만료 공용)")
+@Schema(
+        description = "앨범 참여자 목록 응답 DTO (활성/만료 공용)",
+        requiredProperties = {
+                "isExpired",
+                "title",
+                "themeEmoji",
+                "eventDate",
+                "expiredAt",
+                "maxParticipantCount",
+                "currentParticipantCount",
+                "participants"
+        }
+)
 public record AlbumParticipantResponse(
 
         @Schema(description = "만료 여부", example = "false")

src/main/java/com/cheeeese/album/dto/response/ClosedAlbumPageResponse.java

@@ -0,0 +1,35 @@
+package com.cheeeese.album.dto.response;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Builder;
+
+import java.util.List;
+
+@Builder
+@Schema(
+        description = "닫힌 앨범 목록 페이지 응답",
+        requiredProperties = {
+                "responses",
+                "listSize",
+                "isFirst",
+                "isLast",
+                "hasNext"
+        }
+)
+public record ClosedAlbumPageResponse(
+        @Schema(description = "닫힌 앨범 목록")
+        List<ClosedAlbumSummaryResponse> responses,
+
+        @Schema(description = "현재 페이지의 앨범 수", example = "2")
+        int listSize,
+
+        @Schema(description = "첫 페이지 여부", example = "true")
+        boolean isFirst,
+
+        @Schema(description = "마지막 페이지 여부", example = "false")
+        boolean isLast,
+
+        @Schema(description = "다음 페이지 존재 여부", example = "true")
+        boolean hasNext
+) {
+}

src/main/java/com/cheeeese/album/dto/response/ClosedAlbumSummaryResponse.java

@@ -0,0 +1,35 @@
+package com.cheeeese.album.dto.response;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Builder;
+
+import java.time.LocalDate;
+import java.util.List;
+
+@Builder
+@Schema(
+        description = "닫힌 앨범 요약 정보",
+        requiredProperties = {
+                "code",
+                "title",
+                "makerName",
+                "eventDate"
+        }
+)
+public record ClosedAlbumSummaryResponse(
+        @Schema(description = "앨범 코드", example = "786ccd09-...")
+        String code,
+
+        @Schema(description = "앨범 제목", example = "봄 소풍")
+        String title,
+
+        @Schema(description = "앨범 생성자 이름", example = "치즈메이커")
+        String makerName,
+
+        @Schema(description = "이벤트 날짜", example = "2025-05-01")
+        LocalDate eventDate,
+
+        @Schema(description = "치즈네컷 썸네일 목록 (4개)", nullable = true)
+        List<String> thumbnails
+) {}