feat: post recommendation API

backend/streetdrop-api/build.gradle

@@ -13,6 +13,10 @@ jar {
     enabled = false
 }
 
+ext {
+    set('springCloudVersion', "2022.0.3")
+}
+
 dependencies {
     implementation project(':streetdrop-domain')
     implementation project(':streetdrop-common')
@@ -39,6 +43,13 @@ dependencies {
 
     implementation 'org.springframework.boot:spring-boot-starter-webflux'
     implementation 'io.awspring.cloud:spring-cloud-starter-aws:2.4.4'
+    implementation 'org.springframework.cloud:spring-cloud-starter-openfeign'
+}
+
+dependencyManagement {
+    imports {
+        mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
+    }
 }
 
 

backend/streetdrop-api/src/main/java/com/depromeet/common/error/dto/CommonErrorCode.java

@@ -29,8 +29,8 @@ public enum CommonErrorCode implements ErrorCodeInterface {
 	 * Basic Server Error
 	 */
 	INTERNAL_SERVER_ERROR(HttpStatus.INTERNAL_SERVER_ERROR, "COMMON_INTERNAL_SERVER_ERROR", "Internal Server Error", "An unexpected error occurred"),
-	NOT_IMPLEMENTED(HttpStatus.NOT_IMPLEMENTED, "COMMON_NOT_IMPLEMENTED", "Not Implemented", "The server does not support the functionality required to fulfill the request.");
-
+	NOT_IMPLEMENTED(HttpStatus.NOT_IMPLEMENTED, "COMMON_NOT_IMPLEMENTED", "Not Implemented", "The server does not support the functionality required to fulfill the request."),
+	UNSUPPORTED_TYPE(HttpStatus.BAD_REQUEST, "COMMON_UNSUPPORTED_TYPE", "Unsupported Type", "The type specified is not supported.");
 
 	private final HttpStatus status;
 	private final String errorResponseCode;

backend/streetdrop-api/src/main/java/com/depromeet/domains/music/service/MusicService.java

@@ -8,6 +8,8 @@
 import com.depromeet.domains.music.dto.response.MusicResponseDto;
 import com.depromeet.domains.music.event.CreateSongGenreEvent;
 import com.depromeet.domains.music.song.repository.SongRepository;
+import com.depromeet.domains.recommend.dto.response.RecommendCategoryDto;
+import com.depromeet.domains.recommend.constant.RecommendType;
 import com.depromeet.music.album.Album;
 import com.depromeet.music.album.AlbumCover;
 import com.depromeet.music.artist.Artist;
@@ -120,4 +122,10 @@ public MusicResponseDto getMusic(Long songId) {
 				.map(MusicResponseDto::new)
 				.orElseThrow(() -> new NotFoundException(CommonErrorCode.NOT_FOUND, songId));
 	}
+
+	@Transactional(readOnly = true)
+	public RecommendCategoryDto getRecentMusic(RecommendType recommendType) {
+		var recentSongs = songRepository.findRecentSongs(recommendType.getLimit());
+		return RecommendCategoryDto.ofMusicInfoResponseDto(recommendType, recentSongs);
+	}
 }

backend/streetdrop-api/src/main/java/com/depromeet/domains/music/song/repository/QueryDslSongRepository.java

@@ -0,0 +1,9 @@
+package com.depromeet.domains.music.song.repository;
+
+import com.depromeet.domains.recommend.dto.response.MusicInfoResponseDto;
+
+import java.util.List;
+
+public interface QueryDslSongRepository {
+    List<MusicInfoResponseDto> findRecentSongs(int count);
+}

backend/streetdrop-api/src/main/java/com/depromeet/domains/music/song/repository/SongRepository.java

@@ -7,7 +7,7 @@
 
 import java.util.Optional;
 
-public interface SongRepository extends JpaRepository<Song, Long> {
+public interface SongRepository extends JpaRepository<Song, Long>, QueryDslSongRepository {
 	Optional<Song> findSongByNameAndAlbum(String name, Album album);
 
 	@Query("SELECT s FROM Song s JOIN FETCH s.album " +

backend/streetdrop-api/src/main/java/com/depromeet/domains/music/song/repository/SongRepositoryImpl.java

@@ -0,0 +1,49 @@
+package com.depromeet.domains.music.song.repository;
+
+import com.depromeet.domains.recommend.dto.response.MusicInfoResponseDto;
+import com.querydsl.core.types.Projections;
+import com.querydsl.jpa.impl.JPAQueryFactory;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+import static com.depromeet.item.QItem.item;
+import static com.depromeet.music.album.QAlbum.album;
+import static com.depromeet.music.album.QAlbumCover.albumCover;
+import static com.depromeet.music.artist.QArtist.artist;
+import static com.depromeet.music.song.QSong.song;
+
+@Repository
+@RequiredArgsConstructor
+public class SongRepositoryImpl implements QueryDslSongRepository {
+
+    private final JPAQueryFactory queryFactory;
+
+    @Override
+    public List<MusicInfoResponseDto> findRecentSongs(int count) {
+        return queryFactory.select(
+                        Projections.fields(
+                                MusicInfoResponseDto.class,
+                                album.name,
+                                artist.name,
+                                song.name,
+                                albumCover.albumImage,
+                                albumCover.albumThumbnail,
+                                song.genres
+                        ))
+                .from(item)
+                .join(item.song, song)
+                .on(item.song.id.eq(song.id))
+                .join(song.album, album)
+                .on(song.album.id.eq(album.id))
+                .join(album.artist, artist)
+                .on(album.artist.id.eq(artist.id))
+                .join(album.albumCover, albumCover)
+                .on(album.albumCover.id.eq(albumCover.id))
+                .orderBy(item.createdAt.desc())
+                .limit(count)
+                .fetch();
+    }
+
+}

backend/streetdrop-api/src/main/java/com/depromeet/domains/recommend/constant/RecommendType.java

@@ -0,0 +1,16 @@
+package com.depromeet.domains.recommend.constant;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public enum RecommendType {
+    CHART_SONGS("인기 있는 음악", 30, true),
+    RECENT_SONGS("많이 드랍된 음악", 15, true),
+    CHART_ARTIST("아티스트", 10, false);
+
+    private final String title;
+    private final int limit;
+    private final boolean nextPage;
+}

backend/streetdrop-api/src/main/java/com/depromeet/domains/recommend/controller/SearchRecommendController.java

@@ -1,6 +1,7 @@
 package com.depromeet.domains.recommend.controller;
 
 import com.depromeet.common.dto.ResponseDto;
+import com.depromeet.domains.recommend.dto.response.RecommendResponseDto;
 import com.depromeet.domains.recommend.dto.response.SearchTermRecommendResponseDto;
 import com.depromeet.domains.recommend.service.SearchRecommendService;
 import io.swagger.v3.oas.annotations.Operation;
@@ -12,17 +13,25 @@
 import org.springframework.web.bind.annotation.RestController;
 
 @RestController
-@RequestMapping("/search-term/recommend")
+@RequestMapping
 @RequiredArgsConstructor
 @Tag(name = "💁Search Recommend", description = "Search Recommend API")
 public class SearchRecommendController {
+
     private final SearchRecommendService searchRecommendService;
 
     @Operation(summary = "검색어 추천")
-    @GetMapping
+    @GetMapping("/search-term/recommend")
     public ResponseEntity<SearchTermRecommendResponseDto> recommendSearchTerm() {
         var response = searchRecommendService.recommendSearchTerm();
         return ResponseDto.ok(response);
     }
 
+    @Operation(summary = "검색어 추천 v2")
+    @GetMapping("/v2/search-term/recommend")
+    public ResponseEntity<RecommendResponseDto> recommendSearchTerm2() {
+        var response = searchRecommendService.recommendSearchSongs();
+        return ResponseDto.ok(response);
+    }
+
 }

backend/streetdrop-api/src/main/java/com/depromeet/domains/recommend/dto/response/ArtistInfoResponseDto.java

@@ -0,0 +1,41 @@
+package com.depromeet.domains.recommend.dto.response;
+
+import com.depromeet.external.applemusic.dto.response.catalogchart.AppleMusicAlbumChartResponseDto;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Getter
+@NoArgsConstructor
+@AllArgsConstructor
+public class ArtistInfoResponseDto {
+
+    private static final int MINUTES_PER_HOUR = 60;
+    private static final int TO_SEC = 1000;
+    private static final int ALBUM_IMAGE_SIZE = 500;
+    private static final int ALBUM_THUMBNAIL_IMAGE_SIZE = 100;
+
+    private String artistName;
+    private String albumImage;
+    private String albumThumbnailImage;
+
+    private static String fillSize(String url, int size) {
+        return url.replace("{w}", String.valueOf(size)).replace("{h}", String.valueOf(size));
+    }
+
+    private static String convertToTimeFormat(int totalMilliseconds) {
+        int totalSeconds = totalMilliseconds / TO_SEC;
+        int minutes = totalSeconds / MINUTES_PER_HOUR;
+        int seconds = totalSeconds % MINUTES_PER_HOUR;
+        return String.format("%d:%02d", minutes, seconds);
+    }
+
+    public static ArtistInfoResponseDto fromAppleMusicResponse(AppleMusicAlbumChartResponseDto.AlbumData data) {
+        return new ArtistInfoResponseDto(
+                data.attributes.artistName,
+                fillSize(data.attributes.artwork.url, ALBUM_IMAGE_SIZE),
+                fillSize(data.attributes.artwork.url, ALBUM_THUMBNAIL_IMAGE_SIZE)
+        );
+    }
+
+}

backend/streetdrop-api/src/main/java/com/depromeet/domains/recommend/dto/response/MusicInfoResponseDto.java

@@ -0,0 +1,60 @@
+package com.depromeet.domains.recommend.dto.response;
+
+import com.depromeet.external.applemusic.dto.response.catalogchart.AppleMusicSongChartResponseDto;
+import com.depromeet.music.genre.Genre;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+
+@Getter
+@NoArgsConstructor
+public class MusicInfoResponseDto {
+    private String albumName;
+    private String artistName;
+    private String songName;
+    private String durationTime;
+    private String albumImage;
+    private String albumThumbnailImage;
+    private List<String> genre;
+
+    public MusicInfoResponseDto(String albumName, String artistName, String songName, String albumImage, String albumThumbnailImage, List<Genre> genre) {
+        this.albumName = albumName;
+        this.artistName = artistName;
+        this.songName = songName;
+        this.durationTime = "";  // TODO: DB에서 가져오는 음악 데이터는 durationTime이 없음
+        this.albumImage = albumImage;
+        this.albumThumbnailImage = albumThumbnailImage;
+        this.genre = genre.stream().map(Genre::getName).toList();
+    }
+
+    public static MusicInfoResponseDto fromAppleMusicResponse(AppleMusicSongChartResponseDto.SongData data) {
+        final int MINUTES_PER_HOUR = 60;
+        final int TO_SEC = 1000;
+        final int ALBUM_IMAGE_SIZE = 500;
+        final int ALBUM_THUMBNAIL_IMAGE_SIZE = 100;
+
+        BiFunction<String, Integer, String> fillSize = (s, size) ->
+                s.replace("{w}", String.valueOf(size)).replace("{h}", String.valueOf(size));
+
+        Function<Integer, String> totalSecondsToTime = totalSeconds -> {
+            totalSeconds = totalSeconds / TO_SEC;
+            int minutes = totalSeconds / MINUTES_PER_HOUR;
+            int seconds = totalSeconds % MINUTES_PER_HOUR;
+            return String.format("%d:%02d", minutes, seconds);
+        };
+
+        MusicInfoResponseDto musicInfo = new MusicInfoResponseDto();
+        musicInfo.albumName = data.attributes.albumName;
+        musicInfo.artistName = data.attributes.artistName;
+        musicInfo.songName = data.attributes.name;
+        musicInfo.durationTime = totalSecondsToTime.apply(data.attributes.durationInMillis);
+        musicInfo.albumImage = fillSize.apply(data.attributes.artwork.url, ALBUM_IMAGE_SIZE);
+        musicInfo.albumThumbnailImage = fillSize.apply(data.attributes.artwork.url, ALBUM_THUMBNAIL_IMAGE_SIZE);
+        musicInfo.genre = data.attributes.genreNames;
+        return musicInfo;
+    }
+
+}

backend/streetdrop-api/src/main/java/com/depromeet/domains/recommend/dto/response/RecommendCategoryDto.java

@@ -0,0 +1,47 @@
+package com.depromeet.domains.recommend.dto.response;
+
+import com.depromeet.domains.recommend.constant.RecommendType;
+import com.depromeet.external.applemusic.dto.response.catalogchart.AppleMusicAlbumChartResponseDto;
+import com.depromeet.external.applemusic.dto.response.catalogchart.AppleMusicSongChartResponseDto;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+
+@Getter
+@AllArgsConstructor
+public class RecommendCategoryDto {
+    private String title;
+    private List<?> content;
+    private boolean nextPage;
+
+    public static RecommendCategoryDto ofMusicInfoResponseDto(RecommendType recommendType, List<MusicInfoResponseDto> musicInfoResponseDto) {
+        return new RecommendCategoryDto(recommendType.getTitle(), musicInfoResponseDto, recommendType.isNextPage());
+    }
+
+
+    public static RecommendCategoryDto ofAppleMusicResponseDto(RecommendType recommendType, AppleMusicSongChartResponseDto appleMusicSongChartResponseDto) {
+        List<MusicInfoResponseDto> musicInfoList = Optional.ofNullable(appleMusicSongChartResponseDto.results.songs)
+                .filter(songs -> !songs.isEmpty())
+                .map(songs -> songs.get(0).data.stream()
+                        .map(MusicInfoResponseDto::fromAppleMusicResponse)
+                        .toList()
+                )
+                .orElse(Collections.emptyList());
+        return new RecommendCategoryDto(recommendType.getTitle(), musicInfoList, recommendType.isNextPage());
+    }
+
+    public static RecommendCategoryDto ofAppleMusicResponseDto(RecommendType recommendType, AppleMusicAlbumChartResponseDto appleMusicAlbumChartResponseDto) {
+        List<ArtistInfoResponseDto> artistInfoList =
+                Optional.ofNullable(appleMusicAlbumChartResponseDto.results.albums)
+                        .filter(albums -> !albums.isEmpty())
+                        .map(albums -> albums.get(0).data.stream()
+                                .map(ArtistInfoResponseDto::fromAppleMusicResponse)
+                                .toList()
+                        )
+                        .orElse(Collections.emptyList());
+        return new RecommendCategoryDto(recommendType.getTitle(), artistInfoList, recommendType.isNextPage());
+    }
+}

backend/streetdrop-api/src/main/java/com/depromeet/domains/recommend/dto/response/RecommendResponseDto.java

@@ -0,0 +1,12 @@
+package com.depromeet.domains.recommend.dto.response;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+import java.util.List;
+
+@Getter
+@AllArgsConstructor
+public class RecommendResponseDto {
+    private List<RecommendCategoryDto> data;
+}

backend/streetdrop-api/src/main/java/com/depromeet/domains/recommend/service/SearchRecommendService.java

@@ -2,16 +2,24 @@
 
 import com.depromeet.common.error.dto.CommonErrorCode;
 import com.depromeet.common.error.exception.internal.BusinessException;
-import com.depromeet.domains.recommend.dto.response.SearchTermRecommendResponseDto;
-import com.depromeet.domains.recommend.dto.response.TextColorDto;
+import com.depromeet.domains.music.service.MusicService;
+import com.depromeet.domains.recommend.constant.RecommendType;
+import com.depromeet.domains.recommend.dto.response.*;
 import com.depromeet.domains.recommend.repository.SearchRecommendTermRepository;
+import com.depromeet.external.applemusic.service.AppleMusicService;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 
+import java.util.List;
+
+@Slf4j
 @Service
 @RequiredArgsConstructor
 public class SearchRecommendService {
 
+    private final MusicService musicService;
+    private final AppleMusicService appleMusicService;
     private final SearchRecommendTermRepository searchRecommendTermRepository;
 
     public SearchTermRecommendResponseDto recommendSearchTerm() {
@@ -30,4 +38,15 @@ public SearchTermRecommendResponseDto recommendSearchTerm() {
 
         return new SearchTermRecommendResponseDto(description, termList);
     }
+
+    public RecommendResponseDto recommendSearchSongs() {
+        return new RecommendResponseDto(
+                List.of(
+                        appleMusicService.getCategoryChart(RecommendType.CHART_SONGS),
+                        musicService.getRecentMusic(RecommendType.RECENT_SONGS),
+                        appleMusicService.getCategoryChart(RecommendType.CHART_ARTIST)
+                )
+        );
+    }
+
 }