[release] 수정사항 반영을 위해 배포합니다.

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

@@ -5,12 +5,14 @@
 import org.sopt.confeti.api.performance.dto.request.CreateFestivalRequest;
 import org.sopt.confeti.api.performance.dto.response.ConcertDetailResponse;
 import org.sopt.confeti.api.performance.dto.response.FestivalDetailResponse;
+import org.sopt.confeti.api.performance.dto.response.RecentPerformancesResponse;
 import org.sopt.confeti.api.performance.facade.PerformanceFacade;
 import org.sopt.confeti.api.performance.facade.dto.request.CreateFestivalDTO;
 import org.sopt.confeti.api.performance.facade.dto.response.ConcertDetailDTO;
 import org.sopt.confeti.api.performance.facade.dto.response.FestivalDetailDTO;
 import org.sopt.confeti.api.performance.dto.response.PerformanceReservationResponse;
 import org.sopt.confeti.api.performance.facade.dto.response.PerformanceReservationDTO;
+import org.sopt.confeti.api.performance.facade.dto.response.RecentPerformancesDTO;
 import org.sopt.confeti.global.common.BaseResponse;
 import org.sopt.confeti.global.message.SuccessMessage;
 import org.sopt.confeti.global.util.ApiResponseUtil;
@@ -63,4 +65,12 @@ public ResponseEntity<BaseResponse<?>> getPerformReservationInfo(@RequestHeader(
         PerformanceReservationDTO performanceReservationDTO = performanceFacade.getPerformReservationInfo(userId);
         return ApiResponseUtil.success(SuccessMessage.SUCCESS, PerformanceReservationResponse.of(performanceReservationDTO, s3FileHandler));
     }
+
+    @GetMapping("/info")
+    public ResponseEntity<BaseResponse<?>> getRecentPerformances(
+            @RequestHeader(name = "Authorization", required = false) Long userId
+    ) {
+        RecentPerformancesDTO recentPerformances = performanceFacade.getRecentPerformances(userId);
+        return ApiResponseUtil.success(SuccessMessage.SUCCESS, RecentPerformancesResponse.of(recentPerformances, s3FileHandler));
+    }
 }

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

@@ -0,0 +1,27 @@
+package org.sopt.confeti.api.performance.dto.response;
+
+import org.sopt.confeti.api.performance.facade.dto.response.RecentPerformanceDTO;
+import org.sopt.confeti.global.util.DateConvertor;
+import org.sopt.confeti.global.util.S3FileHandler;
+
+public record RecentPerformanceResponse(
+        long performanceId,
+        long typeId,
+        String type,
+        String title,
+        String subtitle,
+        String performanceAt,
+        String posterUrl
+) {
+    public static RecentPerformanceResponse of(final RecentPerformanceDTO recentPerformanceDTO, final S3FileHandler s3FileHandler) {
+        return new RecentPerformanceResponse(
+                recentPerformanceDTO.performanceId(),
+                recentPerformanceDTO.typeId(),
+                recentPerformanceDTO.type().getType(),
+                recentPerformanceDTO.title(),
+                recentPerformanceDTO.subtitle(),
+                DateConvertor.convertToLocalDate(recentPerformanceDTO.performanceAt()),
+                s3FileHandler.getFileUrl(recentPerformanceDTO.posterPath())
+        );
+    }
+}

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

@@ -0,0 +1,17 @@
+package org.sopt.confeti.api.performance.dto.response;
+
+import java.util.List;
+import org.sopt.confeti.api.performance.facade.dto.response.RecentPerformancesDTO;
+import org.sopt.confeti.global.util.S3FileHandler;
+
+public record RecentPerformancesResponse(
+        List<RecentPerformanceResponse> performances
+) {
+    public static RecentPerformancesResponse of(final RecentPerformancesDTO recentPerformancesDTO, final S3FileHandler s3FileHandler) {
+        return new RecentPerformancesResponse(
+                recentPerformancesDTO.performances().stream()
+                        .map(recentPerformanceDTO -> RecentPerformanceResponse.of(recentPerformanceDTO, s3FileHandler))
+                        .toList()
+        );
+    }
+}

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

@@ -3,37 +3,51 @@
 import java.time.LocalDateTime;
 import java.util.List;
 
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 import lombok.RequiredArgsConstructor;
 import org.sopt.confeti.annotation.Facade;
 import org.sopt.confeti.api.performance.facade.dto.request.CreateFestivalDTO;
 import org.sopt.confeti.api.performance.facade.dto.response.ConcertDetailDTO;
 import org.sopt.confeti.api.performance.facade.dto.response.FestivalDetailDTO;
 import org.sopt.confeti.api.performance.facade.dto.response.PerformanceReservationDTO;
+import org.sopt.confeti.api.performance.facade.dto.response.RecentPerformancesDTO;
+import org.sopt.confeti.domain.artistfavorite.ArtistFavorite;
+import org.sopt.confeti.domain.artistfavorite.application.ArtistFavoriteService;
 import org.sopt.confeti.domain.concert.Concert;
 import org.sopt.confeti.domain.concert.application.ConcertService;
 import org.sopt.confeti.domain.concertfavorite.application.ConcertFavoriteService;
 import org.sopt.confeti.domain.festival.Festival;
 import org.sopt.confeti.domain.festival.application.FestivalService;
 import org.sopt.confeti.domain.festivalfavorite.application.FestivalFavoriteService;
 import org.sopt.confeti.domain.user.application.UserService;
+import org.sopt.confeti.domain.view.performance.Performance;
 import org.sopt.confeti.domain.view.performance.PerformanceTicketDTO;
 import org.sopt.confeti.domain.view.performance.application.PerformanceService;
+import org.sopt.confeti.domain.view.performance.application.dto.request.GetPerformanceIdRequest;
+import org.sopt.confeti.domain.view.performance.application.dto.response.GetPerformanceIdResponse;
+import org.sopt.confeti.global.common.constant.PerformanceType;
 import org.sopt.confeti.global.exception.NotFoundException;
 import org.sopt.confeti.global.message.ErrorMessage;
 import org.sopt.confeti.global.util.S3FileHandler;
+import org.sopt.confeti.global.util.artistsearcher.ConfetiArtist;
 import org.springframework.transaction.annotation.Transactional;
 
 @Facade
 @RequiredArgsConstructor
 public class PerformanceFacade {
 
+    private static final int RECENT_PERFORMANCES_SIZE = 7;
+
     private final ConcertService concertService;
     private final FestivalService festivalService;
     private final UserService userService;
     private final FestivalFavoriteService festivalFavoriteService;
     private final S3FileHandler s3FileHandler;
     private final PerformanceService performanceService;
     private final ConcertFavoriteService concertFavoriteService;
+    private final ArtistFavoriteService artistFavoriteService;
 
     @Transactional(readOnly = true)
     public ConcertDetailDTO getConcertDetailInfo(final Long userId, final long concertId) {
@@ -105,4 +119,43 @@ public PerformanceReservationDTO getPerformReservationInfo(final Long userId){
         List<PerformanceTicketDTO> performanceReserve=performanceService.getPerformancesReservation();
         return PerformanceReservationDTO.from(performanceReserve);
     }
+
+    @Transactional(readOnly = true)
+    public RecentPerformancesDTO getRecentPerformances(final Long userId) {
+        if (userId == null || !hasFavoriteArtists(userId)) {
+            return getRecentPerformancesWithoutFavorites();
+        }
+
+        return getRecentPerformancesWithFavorites(userId);
+    }
+
+    @Transactional(readOnly = true)
+    public RecentPerformancesDTO getRecentPerformancesWithFavorites(final long userId) {
+        List<ArtistFavorite> artistFavorites = artistFavoriteService.getArtistList(userId);
+
+        return RecentPerformancesDTO.from(
+                performanceService.getPerformancesByArtistIds(
+                        artistFavorites.stream()
+                                .map(artistFavorite -> artistFavorite.getArtist().getArtistId())
+                                .toList(),
+                        RECENT_PERFORMANCES_SIZE
+                )
+        );
+    }
+
+    @Transactional(readOnly = true)
+    public RecentPerformancesDTO getRecentPerformancesWithoutFavorites() {
+        // 최신 콘서트 조회
+        List<Concert> concerts = concertService.getRecentConcerts(RECENT_PERFORMANCES_SIZE);
+
+        // 최신 페스티벌 조회
+        List<Festival> festivals = festivalService.getRecentFestivals(RECENT_PERFORMANCES_SIZE);
+
+        return RecentPerformancesDTO.of(concerts, festivals);
+    }
+
+    @Transactional(readOnly = true)
+    public boolean hasFavoriteArtists(final long userId) {
+        return artistFavoriteService.existsByUserId(userId);
+    }
 }

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

@@ -0,0 +1,53 @@
+package org.sopt.confeti.api.performance.facade.dto.response;
+
+import java.time.LocalDateTime;
+import org.sopt.confeti.domain.concert.Concert;
+import org.sopt.confeti.domain.festival.Festival;
+import org.sopt.confeti.domain.view.performance.Performance;
+import org.sopt.confeti.global.common.constant.PerformanceType;
+
+public record RecentPerformanceDTO(
+        long performanceId,
+        long typeId,
+        PerformanceType type,
+        String title,
+        String subtitle,
+        LocalDateTime performanceAt,
+        String posterPath
+) {
+    public static RecentPerformanceDTO of(final Concert concert, final long performanceId) {
+        return new RecentPerformanceDTO(
+                performanceId,
+                concert.getId(),
+                PerformanceType.CONCERT,
+                concert.getConcertTitle(),
+                concert.getConcertSubtitle(),
+                concert.getConcertStartAt(),
+                concert.getConcertPosterPath()
+        );
+    }
+
+    public static RecentPerformanceDTO of(final Festival festival, final long performanceId) {
+        return new RecentPerformanceDTO(
+                performanceId,
+                festival.getId(),
+                PerformanceType.FESTIVAL,
+                festival.getFestivalTitle(),
+                festival.getFestivalSubtitle(),
+                festival.getFestivalStartAt(),
+                festival.getFestivalPosterPath()
+        );
+    }
+
+    public static RecentPerformanceDTO from(final Performance performance) {
+        return new RecentPerformanceDTO(
+                performance.getId(),
+                performance.getTypeId(),
+                performance.getType(),
+                performance.getTitle(),
+                performance.getSubtitle(),
+                performance.getStartAt(),
+                performance.getPosterPath()
+        );
+    }
+}

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

@@ -0,0 +1,34 @@
+package org.sopt.confeti.api.performance.facade.dto.response;
+
+import java.util.List;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+import org.sopt.confeti.domain.concert.Concert;
+import org.sopt.confeti.domain.festival.Festival;
+import org.sopt.confeti.domain.view.performance.Performance;
+
+public record RecentPerformancesDTO(
+        List<RecentPerformanceDTO> performances
+) {
+    public static RecentPerformancesDTO of(
+            List<Concert> concerts,
+            List<Festival> festivals
+    ) {
+        return new RecentPerformancesDTO(
+                Stream.concat(
+                        IntStream.range(0, concerts.size())
+                                .mapToObj(i -> RecentPerformanceDTO.of(concerts.get(i), i)),
+                        IntStream.range(concerts.size(), festivals.size())
+                                .mapToObj(i -> RecentPerformanceDTO.of(festivals.get(i), i))
+                ).toList()
+        );
+    }
+
+    public static RecentPerformancesDTO from(final List<Performance> performances) {
+        return new RecentPerformancesDTO(
+                performances.stream()
+                        .map(RecentPerformanceDTO::from)
+                        .toList()
+        );
+    }
+}

src/main/java/org/sopt/confeti/api/user/facade/UserFavoriteFacade.java

@@ -123,7 +123,7 @@ public void addConcertFavorite(final long userId, final long concertId) {
         User user = userService.findById(userId);
         Concert concert = concertService.findById(concertId);
 
-        validateExistConcertFavorite(userId, concertId);
+        validateNotExistConcertFavorite(userId, concertId);
 
         concertFavoriteService.addFavorite(user, concert);
     }
@@ -152,6 +152,13 @@ protected void validateExistConcertFavorite(final long userId, final long concer
         }
     }
 
+    @Transactional(readOnly = true)
+    protected void validateNotExistConcertFavorite(final long userId, final long concertId) {
+        if (concertFavoriteService.isFavorite(userId, concertId)) {
+            throw new ConflictException(ErrorMessage.CONFLICT);
+        }
+    }
+
     @Transactional(readOnly = true)
     protected void validateExistUser(final long userId) {
         if (!userService.existsById(userId)) {

src/main/java/org/sopt/confeti/api/user/facade/UserTimetableFacade.java

@@ -51,6 +51,7 @@ public class UserTimetableFacade {
     private final ArtistResolver artistResolver;
     private final UserTimetableService userTimetableService;
 
+    @Transactional(readOnly = true)
     public UserTimetableDTO getTimetablesListAndDate(long userId) {
         validateExistUser(userId);
 

src/main/java/org/sopt/confeti/domain/artistfavorite/application/ArtistFavoriteService.java

@@ -41,4 +41,9 @@ public void addFavorite(final User user, final String artistId) {
     public void removeFavorite(final long userId, final String artistId) {
         artistFavoriteRepository.deleteByUserIdAndArtist_ArtistId(userId, artistId);
     }
+
+    @Transactional(readOnly = true)
+    public boolean existsByUserId(final long userId) {
+        return artistFavoriteRepository.existsByUserId(userId);
+    }
 }

src/main/java/org/sopt/confeti/domain/artistfavorite/infra/repository/ArtistFavoriteRepository.java

@@ -14,4 +14,6 @@ public interface ArtistFavoriteRepository extends JpaRepository<ArtistFavorite,
     boolean existsByUserIdAndArtist_ArtistId(long userId, String artistId);
 
     void deleteByUserIdAndArtist_ArtistId(final long userId, final String artistId);
+
+    boolean existsByUserId(final long userId);
 }

src/main/java/org/sopt/confeti/domain/concert/application/ConcertService.java

@@ -1,18 +1,26 @@
 package org.sopt.confeti.domain.concert.application;
 
+import java.time.LocalDateTime;
+import java.util.List;
 import lombok.RequiredArgsConstructor;
 import org.sopt.confeti.domain.concert.Concert;
 import org.sopt.confeti.domain.concert.infra.repository.ConcertRepository;
 import org.sopt.confeti.global.exception.NotFoundException;
 import org.sopt.confeti.global.message.ErrorMessage;
 import org.sopt.confeti.global.util.artistsearcher.ArtistResolver;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.domain.Sort.Order;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 @Service
 @RequiredArgsConstructor
 public class ConcertService {
 
+    private static final int INIT_PAGE = 0;
+    private static final String START_AT_COLUMN = "concertStartAt";
+
     private final ConcertRepository concertRepository;
     private final ArtistResolver artistResolver;
 
@@ -40,4 +48,22 @@ public Concert findById(final long concertId) {
                         () -> new NotFoundException(ErrorMessage.NOT_FOUND)
                 );
     }
+
+    @Transactional(readOnly = true)
+    public List<Concert> getRecentConcerts(final int size) {
+        return concertRepository.findAllByConcertEndAtGreaterThanEqual(
+                LocalDateTime.now(),
+                getPageRequest(size, getRecentConcertsSort())
+        );
+    }
+
+    private PageRequest getPageRequest(final int size, final Sort sort) {
+        return PageRequest.of(INIT_PAGE, size, sort);
+    }
+
+    private Sort getRecentConcertsSort() {
+        return Sort.by(
+                Order.asc(START_AT_COLUMN)
+        );
+    }
 }

src/main/java/org/sopt/confeti/domain/concert/infra/repository/ConcertRepository.java

@@ -1,7 +1,12 @@
 package org.sopt.confeti.domain.concert.infra.repository;
 
+import java.time.LocalDateTime;
+import java.util.List;
 import org.sopt.confeti.domain.concert.Concert;
+import org.springframework.data.domain.PageRequest;
 import org.springframework.data.jpa.repository.JpaRepository;
 
 public interface ConcertRepository extends JpaRepository<Concert, Long> {
+
+    List<Concert> findAllByConcertEndAtGreaterThanEqual(final LocalDateTime localDateTime, PageRequest pageRequest);
 }