refactor [#451] 2차 스프린트 기간 코드리뷰 사항 반영

.gitignore

@@ -5,7 +5,7 @@ build/
 !**/src/main/**/build/
 !**/src/test/**/build/
 application*.yml
-**/src/main/resources/static/swagger-ui/openapi3.yaml
+src/main/resources/static/swagger-ui/openapi3.yaml
 
 ### STS ###
 .apt_generated

src/main/java/org/sopt/confeti/api/performance/controller/PerformanceController.java

@@ -3,8 +3,11 @@
 import jakarta.validation.constraints.Max;
 import jakarta.validation.constraints.Min;
 import jakarta.validation.constraints.NotBlank;
-import java.util.Arrays;
 import java.util.List;
+import java.util.Optional;
+import java.util.Arrays;
+import java.util.Objects;
+import java.util.Collections;
 import lombok.RequiredArgsConstructor;
 import org.sopt.confeti.api.performance.dto.request.GetExpectedPerformanceRequest;
 import org.sopt.confeti.api.performance.dto.response.ArtistPerformancesResponse;
@@ -144,9 +147,14 @@ public ResponseEntity<BaseResponse<?>> searchAutoComplete(
     public ResponseEntity<BaseResponse<?>> getRecommendPerformanceId(
             @UserId(require = false) Long userId
     ) {
-        RecommendMusicsPerformanceDTO recommendMusicsDTO = performanceFacade.getRecommendPerformanceId(userId);
-        return ApiResponseUtil.success(SuccessMessage.SUCCESS,
-                RecommendMusicsPerformanceResponse.from(recommendMusicsDTO));
+        Optional<RecommendMusicsPerformanceDTO> performanceDto = Objects.isNull(userId)
+                ? performanceFacade.getRecommendPerformanceIdByRand()
+                : performanceFacade.getRecommendPerformanceIdByUserId(userId);
+
+        return performanceDto
+                .map(performance ->
+                        ApiResponseUtil.success(SuccessMessage.SUCCESS, RecommendMusicsPerformanceResponse.from(performance)))
+                .orElseGet(()-> ApiResponseUtil.success(SuccessMessage.SUCCESS, Collections.emptyMap()));
     }
 
     @Permission(role = {Role.GENERAL})

src/main/java/org/sopt/confeti/api/performance/facade/PerformanceFacade.java

@@ -1,14 +1,15 @@
 package org.sopt.confeti.api.performance.facade;
 
 import java.time.LocalDate;
-import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.Optional;
 import java.util.stream.Collectors;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -26,6 +27,7 @@
 import org.sopt.confeti.api.performance.facade.dto.response.RecommendPerformancesDTO;
 import org.sopt.confeti.api.performance.facade.dto.response.SearchACPerformancesDTO;
 import org.sopt.confeti.api.performance.facade.dto.response.PerformanceIdsDTO;
+import org.sopt.confeti.api.performance.vo.UserPerformanceRecordVO;
 import org.sopt.confeti.domain.artist_favorite.ArtistFavorite;
 import org.sopt.confeti.domain.artist_favorite.application.ArtistFavoriteService;
 import org.sopt.confeti.domain.concert.Concert;
@@ -36,6 +38,7 @@
 import org.sopt.confeti.domain.festival.Festival;
 import org.sopt.confeti.domain.festival.application.FestivalService;
 import org.sopt.confeti.domain.festival_favorite.application.FestivalFavoriteService;
+import org.sopt.confeti.domain.setlist.SetlistType;
 import org.sopt.confeti.domain.setlist.application.SetlistService;
 import org.sopt.confeti.domain.timetable_festival.application.TimetableFestivalService;
 import org.sopt.confeti.domain.user.application.UserService;
@@ -61,6 +64,8 @@ public class PerformanceFacade {
 
     private static final int RECENT_PERFORMANCES_SIZE = 7;
     private static final int RECOMMEND_MUSIC_SIZE = 3;
+    private static final int MUSIC_FETCH_SIZE = 5;
+    private static final int SELECTED_ARTISTS_SIZE = 3;
     private static final boolean PERSONALIZED = true;
     private static final boolean UNPERSONALIZED = false;
 
@@ -261,98 +266,89 @@ public SearchACPerformancesDTO searchACPerformances(String term, int limit, Perf
         );
     }
 
-    @Transactional(readOnly = true)
-    public RecommendMusicsPerformanceDTO getRecommendPerformanceId(final Long userId) {
-
-        Performance performance = performanceService.getPerformanceByUserFavorites(userId);
-        if (userId == null || performance == null) {
-            performance = performanceService.getPerformanceByRand();
-        }
-
-        return RecommendMusicsPerformanceDTO.from(performance);
+    public Optional<RecommendMusicsPerformanceDTO> getRecommendPerformanceIdByRand() {
+        return performanceService.getPerformanceByRand()
+                .map(RecommendMusicsPerformanceDTO::from);
     }
 
-    protected Set<String> setArtistsByRandom(Performance performance) {
-        List<PerformanceArtist> performanceArtists = performance.getArtists();
-
-        if (performanceArtists.isEmpty()) {
-            return Collections.emptySet();
-        }
-
-        List<String> artistList = performanceArtists.stream()
-                .map(PerformanceArtist::getArtistId).distinct().collect(Collectors.toList());
-        Collections.shuffle(artistList);
-
-        int artistCount = Math.min(artistList.size(), 3);
-        return new HashSet<>(artistList.subList(0, artistCount));
+    public Optional<RecommendMusicsPerformanceDTO> getRecommendPerformanceIdByUserId(final Long userId) {
+        return performanceService.getPerformanceByUserFavorites(userId)
+                .map(RecommendMusicsPerformanceDTO::from);
     }
 
     @Transactional(readOnly = true)
     public RecommendMusicsDTO getNewRecommendMusics(long performanceId, List<String> musicIds) {
         Performance performance = performanceService.getPerformanceById(performanceId);
-        Set<String> selectedArtistIds = setArtistsByRandom(performance);
+        Set<String> selectedArtistIds = selectRandomArtistIds(performance);
         Set<String> existingMusicIds = (musicIds == null || musicIds.isEmpty())
                 ? Collections.emptySet()
-                : musicIds.stream().flatMap(ids -> Arrays.stream(ids.split(",")))
-                        .map(String::trim).collect(Collectors.toSet());
+                : musicIds.stream()
+                    .flatMap(ids -> Arrays.stream(ids.split(",")))
+                    .map(String::trim)
+                    .collect(Collectors.toSet());
 
         List<String> artistIdList = new ArrayList<>(selectedArtistIds);
         List<ConfetiMusic> recommendMusics = recommendMusicsByArtistCount(artistIdList, existingMusicIds);
 
         return RecommendMusicsDTO.from(recommendMusics);
     }
 
-    private List<ConfetiMusic> recommendMusicsByArtistCount(List<String> artistIdList, Set<String> existingMusicIds) {
-        int artistCount = artistIdList.size();
-        if (artistCount == 1) {
-            return recommendForSingleArtist(artistIdList, existingMusicIds);
-        }
-        if (artistCount == 2) {
-            return recommendForTwoArtists(artistIdList, existingMusicIds);
+    protected Set<String> selectRandomArtistIds(Performance performance) {
+        List<PerformanceArtist> performanceArtists = performance.getArtists();
+
+        if (performanceArtists.isEmpty()) {
+            return Collections.emptySet();
         }
-        return recommendForMultipleArtists(artistIdList, existingMusicIds);
-    }
 
-    private List<ConfetiMusic> recommendForSingleArtist(List<String> artistIdList, Set<String> existingMusicIds) {
-        return musicAPIHandler.getFilteredTopSongsByArtist(
-                artistIdList.getFirst(), RECOMMEND_MUSIC_SIZE, existingMusicIds
-        );
-    }
+        List<String> artistList = performanceArtists.stream()
+                .map(PerformanceArtist::getArtistId).distinct().collect(Collectors.toList());
+        Collections.shuffle(artistList);
 
-    private List<ConfetiMusic> recommendForTwoArtists(List<String> artistIdList, Set<String> existingMusicIds) {
-        List<ConfetiMusic> musics = new ArrayList<>();
-        musics.addAll(musicAPIHandler.getFilteredTopSongsByArtist(artistIdList.getFirst(), 2, existingMusicIds));
-        musics.addAll(musicAPIHandler.getFilteredTopSongsByArtist(artistIdList.getLast(), 1, existingMusicIds));
-        return musics;
+        int artistCount = Math.min(artistList.size(), SELECTED_ARTISTS_SIZE);
+        return new HashSet<>(artistList.subList(0, artistCount));
     }
 
-    private List<ConfetiMusic> recommendForMultipleArtists(List<String> artistIdList, Set<String> existingMusicIds) {
+    private List<ConfetiMusic> recommendMusicsByArtistCount(List<String> artistIdList, Set<String> existingMusicIds) {
         List<ConfetiMusic> musics = new ArrayList<>();
-        for (String artistId : artistIdList) {
-            if (musics.size() >= RECOMMEND_MUSIC_SIZE) {
-                break;
+        Set<String> seenMusicIds = new HashSet<>(existingMusicIds);
+        int round = 0;
+
+        while (musics.size() < RECOMMEND_MUSIC_SIZE && round < MUSIC_FETCH_SIZE) {
+            for (String artistId : artistIdList) {
+                if (musics.size() >= RECOMMEND_MUSIC_SIZE) break;
+
+                List<ConfetiMusic> topSongs = musicAPIHandler.getFilteredTopSongsByArtist(
+                        artistId, MUSIC_FETCH_SIZE, seenMusicIds
+                );
+
+                if (round < topSongs.size()) {
+                    ConfetiMusic song = topSongs.get(round);
+                    if (!seenMusicIds.contains(song.getId())) {
+                        musics.add(song);
+                        seenMusicIds.add(song.getId());
+                    }
+                }
             }
-            musics.addAll(musicAPIHandler.getFilteredTopSongsByArtist(artistId, 1, existingMusicIds));
+            round++;
         }
+
         return musics;
     }
 
-    @Transactional(readOnly = true)
     public ConfetiRecordDTO getConfetiRecord(final long userId) {
         validateExistUser(userId);
 
         List<Long> timetableFestivalIds = timetableFestivalService.findFestivalIdsByUserId(userId);
-        List<Long> setListFestivalIds = setlistService.findFestivalIdsByUserId(userId);
-        List<Long> setListConcertIds = setlistService.findConcertIdsByUserId(userId);
+        List<Long> setListFestivalIds = setlistService.findMusicIdsByUserId(userId, SetlistType.FESTIVAL);
+        List<Long> setListConcertIds = setlistService.findMusicIdsByUserId(userId, SetlistType.CONCERT);
 
-        Set<Long> uniqueFestivalIds = new HashSet<>();
-        uniqueFestivalIds.addAll(timetableFestivalIds);
-        uniqueFestivalIds.addAll(setListFestivalIds);
-
-        int totalCount = uniqueFestivalIds.size() + setListConcertIds.size();
+        UserPerformanceRecordVO record = new UserPerformanceRecordVO(
+                timetableFestivalIds,
+                setListFestivalIds,
+                setListConcertIds
+        );
 
-        return ConfetiRecordDTO.of(totalCount, timetableFestivalIds.size(),
-                setListFestivalIds.size() + setListConcertIds.size());
+        return ConfetiRecordDTO.from(record);
     }
 
     protected void validateExistUser(final long userId) {

src/main/java/org/sopt/confeti/api/performance/facade/dto/response/ConfetiRecordDTO.java

@@ -1,13 +1,17 @@
 package org.sopt.confeti.api.performance.facade.dto.response;
 
+import org.sopt.confeti.api.performance.vo.UserPerformanceRecordVO;
+
 public record ConfetiRecordDTO(
         long totalCount,
         long timetableCount,
         long setlistCount
 ) {
-    public static ConfetiRecordDTO of(final long totalCount, final long timetableCount, final long setlistCount) {
+    public static ConfetiRecordDTO from(UserPerformanceRecordVO record) {
         return new ConfetiRecordDTO(
-                totalCount, timetableCount, setlistCount
+                record.getTotalUniquePerformanceCount(),
+                record.getTimetableFestivalCount(),
+                record.getSetListPerformanceCount()
         );
     }
 }

src/main/java/org/sopt/confeti/api/performance/vo/UserPerformanceRecordVO.java

@@ -0,0 +1,25 @@
+package org.sopt.confeti.api.performance.vo;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public record UserPerformanceRecordVO(
+        List<Long> timetableFestivalIds,
+        List<Long> setListFestivalIds,
+        List<Long> setListConcertIds
+) {
+    public int getTotalUniquePerformanceCount() {
+        Set<Long> uniqueFestivalIds = new HashSet<>(timetableFestivalIds);
+        uniqueFestivalIds.addAll(setListFestivalIds);
+        return uniqueFestivalIds.size() + setListConcertIds.size();
+    }
+
+    public int getTimetableFestivalCount() {
+        return timetableFestivalIds.size();
+    }
+
+    public int getSetListPerformanceCount() {
+        return setListFestivalIds.size() + setListConcertIds.size();
+    }
+}

src/main/java/org/sopt/confeti/api/user/controller/UserFavoriteController.java

@@ -2,6 +2,7 @@
 
 import jakarta.validation.constraints.Min;
 import java.util.Collections;
+import java.util.Optional;
 import lombok.RequiredArgsConstructor;
 import org.sopt.confeti.api.user.dto.response.UpcomingPerformanceResponse;
 import org.sopt.confeti.api.user.dto.response.UserFavoriteArtistsPreviewResponse;
@@ -137,12 +138,11 @@ public ResponseEntity<BaseResponse<?>> getFavoritePerformancesAll(
     public ResponseEntity<BaseResponse<?>> getUpcomingPerformance(
             @UserId Long userId
     ) {
-        UpcomingPerformanceDTO upcomingPerformanceDTO = userFavoriteFacade.getUpcomingPerformance(userId);
-        if (upcomingPerformanceDTO == null) {
-            return ApiResponseUtil.success(SuccessMessage.SUCCESS, Collections.emptyMap());
-        }
-        return ApiResponseUtil.success(SuccessMessage.SUCCESS,
-                UpcomingPerformanceResponse.of(upcomingPerformanceDTO, s3FileHandler));
+        Optional<UpcomingPerformanceDTO> upcomingPerformanceDTO = userFavoriteFacade.getUpcomingPerformance(userId);
+        return upcomingPerformanceDTO
+                .map(performanceDTO ->
+                        ApiResponseUtil.success(SuccessMessage.SUCCESS, UpcomingPerformanceResponse.of(performanceDTO, s3FileHandler)))
+                .orElseGet(() -> ApiResponseUtil.success(SuccessMessage.SUCCESS, Collections.emptyMap()));
     }
 
     @Permission(role = {Role.GENERAL})

src/main/java/org/sopt/confeti/api/user/controller/UserFavoriteSortType.java

@@ -0,0 +1,28 @@
+package org.sopt.confeti.api.user.controller;
+
+import org.sopt.confeti.global.exception.ConfetiException;
+import org.sopt.confeti.global.message.ErrorMessage;
+
+import java.util.Arrays;
+
+public enum UserFavoriteSortType {
+    CREATED_AT("createdAt"),
+    ALPHABETICALLY("alphabetically");
+
+    private final String value;
+
+    UserFavoriteSortType(String value) {
+        this.value = value;
+    }
+
+    public static UserFavoriteSortType from(String value) {
+        return Arrays.stream(values())
+                .filter(type -> type.value.equalsIgnoreCase(value))
+                .findFirst()
+                .orElseThrow(() -> new ConfetiException(ErrorMessage.BAD_REQUEST));
+    }
+
+    public String getValue() {
+        return value;
+    }
+}

src/main/java/org/sopt/confeti/api/user/controller/UserTimetableSortType.java

@@ -0,0 +1,28 @@
+package org.sopt.confeti.api.user.controller;
+
+import org.sopt.confeti.global.exception.ConfetiException;
+import org.sopt.confeti.global.message.ErrorMessage;
+
+import java.util.Arrays;
+
+public enum UserTimetableSortType {
+    OLDEST_FIRST("oldestFirst"),
+    CREATED_AT("createdAt");
+
+    private final String value;
+
+    UserTimetableSortType(String value) {
+        this.value = value;
+    }
+
+    public static UserTimetableSortType from(String value) {
+        return Arrays.stream(values())
+                .filter(type -> type.value.equalsIgnoreCase(value))
+                .findFirst()
+                .orElseThrow(() -> new ConfetiException(ErrorMessage.BAD_REQUEST));
+    }
+
+    public String getValue() {
+        return value;
+    }
+}