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,9 @@
 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.MusicInfoResponseDto;
+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 +123,13 @@ 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());
+		List<MusicInfoResponseDto> musicInfoResponseDtos = recentSongs.stream()
+				.map(MusicInfoResponseDto::ofSong)
+				.toList();
+		return RecommendCategoryDto.ofMusicInfoResponseDto(recommendType, musicInfoResponseDtos);
+	}
 }

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

@@ -4,7 +4,9 @@
 import com.depromeet.music.song.Song;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
 
+import java.util.List;
 import java.util.Optional;
 
 public interface SongRepository extends JpaRepository<Song, Long> {
@@ -16,4 +18,14 @@ public interface SongRepository extends JpaRepository<Song, Long> {
 			"JOIN FETCH s.album.artist " +
 			"JOIN FETCH s.album.albumCover WHERE s.id = :id")
 	Optional<Song> findSongById(Long id);
+
+	@Query(nativeQuery = true,
+			value = "SELECT DISTINCT s.* FROM (" +
+					"   SELECT s.* FROM song s " +
+					"   JOIN item i ON s.song_id = i.song_id " +
+					"   ORDER BY i.created_at DESC " +
+					"   LIMIT :count" +
+					") s")
+	List<Song> findRecentSongs(@Param("count") int count);
+
 }

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 {
+    POPULAR_CHART_SONG("지금 인기 있는 음악", 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,68 @@
+package com.depromeet.domains.recommend.dto.response;
+
+import com.depromeet.external.applemusic.dto.response.catalogchart.AppleMusicSongChartResponseDto;
+import com.depromeet.music.genre.Genre;
+import com.depromeet.music.song.Song;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+
+@Getter
+@NoArgsConstructor
+@AllArgsConstructor
+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 static MusicInfoResponseDto ofSong(Song song) {
+        return new MusicInfoResponseDto(
+                song.getAlbum().getName(),
+                song.getAlbum().getArtist().getName(),
+                song.getName(),
+                "",
+                song.getAlbum().getAlbumCover().getAlbumImage(),
+                song.getAlbum().getAlbumCover().getAlbumThumbnail(),
+                song.getGenres()
+                        .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,22 @@
 
 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 org.springframework.stereotype.Service;
 
+import java.util.List;
+
 @Service
 @RequiredArgsConstructor
 public class SearchRecommendService {
 
+    private final MusicService musicService;
+    private final AppleMusicService appleMusicService;
     private final SearchRecommendTermRepository searchRecommendTermRepository;
 
     public SearchTermRecommendResponseDto recommendSearchTerm() {
@@ -30,4 +36,15 @@ public SearchTermRecommendResponseDto recommendSearchTerm() {
 
         return new SearchTermRecommendResponseDto(description, termList);
     }
+
+    public RecommendResponseDto recommendSearchSongs() {
+        return new RecommendResponseDto(
+                List.of(
+                        appleMusicService.getCategoryChart(RecommendType.POPULAR_CHART_SONG),
+                        musicService.getRecentMusic(RecommendType.RECENT_SONGS),
+                        appleMusicService.getCategoryChart(RecommendType.CHART_ARTIST)
+                )
+        );
+    }
+
 }

backend/streetdrop-api/src/main/java/com/depromeet/external/applemusic/config/AppleMusicAuthConfig.java

@@ -0,0 +1,22 @@
+package com.depromeet.external.applemusic.config;
+
+import feign.RequestInterceptor;
+import feign.RequestTemplate;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+public class AppleMusicAuthConfig implements RequestInterceptor {
+
+    private static final String HEADER_NAME ="Authorization";
+    private static final String AUTH_TYPE = "Bearer";
+
+    @Value("${apple.music.api.key}")
+    private String value;
+
+    @Override
+    public void apply(RequestTemplate requestTemplate) {
+        requestTemplate.header(HEADER_NAME, AUTH_TYPE + " " + value);
+    }
+
+}