feat: #44 플레이리스트 생성

src/main/java/com/cabin/plat/domain/playlist/mapper/PlaylistMapper.java

@@ -1,7 +1,35 @@
 package com.cabin.plat.domain.playlist.mapper;
 
+import com.cabin.plat.domain.member.entity.Member;
+import com.cabin.plat.domain.playlist.dto.PlaylistRequest.PlaylistUpload;
+import com.cabin.plat.domain.playlist.dto.PlaylistResponse;
+import com.cabin.plat.domain.playlist.entity.Playlist;
+import com.cabin.plat.domain.playlist.entity.PlaylistTrack;
+import com.cabin.plat.domain.track.entity.Track;
 import org.springframework.stereotype.Component;
 
 @Component
 public class PlaylistMapper {
+
+    public Playlist toPlaylist(Member member, PlaylistUpload playlistUpload) {
+        return Playlist.builder()
+                .member(member)
+                .title(playlistUpload.getTitle())
+                .playlistImageUrl(playlistUpload.getPlaylistImageUrl())
+                .build();
+    }
+
+    public PlaylistTrack toPlaylistTrack(Playlist playlist, Track track, int orderIndex) {
+        return PlaylistTrack.builder()
+                .playlist(playlist)
+                .track(track)
+                .orderIndex(orderIndex)
+                .build();
+    }
+
+    public PlaylistResponse.PlayListId toPlaylistId(Long playlistId) {
+        return PlaylistResponse.PlayListId.builder()
+                .playlistId(playlistId)
+                .build();
+    }
 }

src/main/java/com/cabin/plat/domain/playlist/service/PlaylistServiceImpl.java

@@ -1,22 +1,52 @@
 package com.cabin.plat.domain.playlist.service;
 
 import com.cabin.plat.domain.member.entity.Member;
+import com.cabin.plat.domain.member.repository.MemberRepository;
 import com.cabin.plat.domain.playlist.dto.PlaylistRequest;
 import com.cabin.plat.domain.playlist.dto.PlaylistResponse;
+import com.cabin.plat.domain.playlist.entity.Playlist;
+import com.cabin.plat.domain.playlist.entity.PlaylistTrack;
 import com.cabin.plat.domain.playlist.mapper.PlaylistMapper;
 import com.cabin.plat.domain.playlist.repository.PlaylistRepository;
+import com.cabin.plat.domain.playlist.repository.PlaylistTrackRepository;
+import com.cabin.plat.domain.track.entity.Track;
+import com.cabin.plat.domain.track.repository.TrackRepository;
+import com.cabin.plat.domain.track.service.TrackService;
+import com.cabin.plat.global.exception.RestApiException;
+import com.cabin.plat.global.exception.errorCode.TrackErrorCode;
+import java.util.List;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
 @Service
 @RequiredArgsConstructor
 public class PlaylistServiceImpl implements PlaylistService {
+
+    private final TrackService trackService;
     private final PlaylistRepository playlistRepository;
+    private final MemberRepository memberRepository;
+    private final TrackRepository trackRepository;
+    private final PlaylistTrackRepository playlistTrackRepository;
     private final PlaylistMapper playlistMapper;
 
+    @Transactional
     @Override
     public PlaylistResponse.PlayListId addPlaylist(Member member, PlaylistRequest.PlaylistUpload playlistUpload) {
-        return null;
+        Playlist playlist = playlistMapper.toPlaylist(member, playlistUpload);
+        playlistRepository.save(playlist);
+
+        List<PlaylistRequest.PlaylistUpload.TrackOrder> trackOrders = playlistUpload.getTracks();
+        List<PlaylistTrack> playlistTracks = trackOrders.stream()
+                .map(trackOrder -> {
+                    Track track = findTrackById(trackOrder.getTrackId());
+                    return playlistMapper.toPlaylistTrack(playlist, track, trackOrder.getOrderIndex());
+                })
+                .toList();
+
+        playlistTrackRepository.saveAll(playlistTracks);
+
+        return playlistMapper.toPlaylistId(playlist.getId());
     }
 
     @Override
@@ -48,4 +78,9 @@ public PlaylistResponse.PlayListId updatePlaylist(Member member, Long playlistId
     public PlaylistResponse.PlayListId addTrackToPlaylist(Member member, Long playlistId, PlaylistRequest.TrackId trackId) {
         return null;
     }
+
+    private Track findTrackById(Long trackId) {
+        return trackRepository.findById(trackId)
+                .orElseThrow(() -> new RestApiException(TrackErrorCode.TRACK_NOT_FOUND));
+    }
 }

src/test/java/com/cabin/plat/domain/playlist/service/PlaylistServiceImplTest.java

@@ -167,49 +167,49 @@ private List<Long> createTestPlaylists(List<Member> members, List<PlaylistUpload
     class AddPlaylist {
 
         @Test
-        void 플레이리스트_생성_테스트() {
+        void 플레이리스트_테이블_생성_테스트() {
             // given
             Long playlistId = playlistIds.get(0);
 
             // when
             Optional<Playlist> optionalPlaylist = playlistRepository.findById(playlistId); // 저장된 플레이리스트 확인
 
             // then
-            assertThat(playlistId).isNotNull();
             assertThat(optionalPlaylist.isPresent()).isTrue();
             Playlist playlist = optionalPlaylist.get();
 
             assertThat(playlist.getTitle()).isEqualTo("플레이리스트 제목0");
             assertThat(playlist.getPlaylistImageUrl()).isEqualTo("https://test0.com");
-            assertThat(playlist.getPlaylistTracks().get(0).getId()).isEqualTo(tracks.get(0).getId());
-            assertThat(playlist.getPlaylistTracks().get(0).getOrderIndex()).isEqualTo(0);
-            assertThat(playlist.getPlaylistTracks().get(1).getId()).isEqualTo(tracks.get(1).getId());
-            assertThat(playlist.getPlaylistTracks().get(1).getOrderIndex()).isEqualTo(1);
+            assertThat(playlist.getMember().getNickname()).isEqualTo("닉네임1");
         }
 
         @Test
         void 플레이리스트_트랙_관계_테이블_생성_테스트() {
-            // given
-            Optional<PlaylistTrack> optionalPlaylistTrack1 = playlistTrackRepository.findById(1L);
-            Optional<PlaylistTrack> optionalPlaylistTrack2 = playlistTrackRepository.findById(2L);
-
-            // when
-            assertThat(optionalPlaylistTrack1.isPresent()).isTrue();
-            assertThat(optionalPlaylistTrack2.isPresent()).isTrue();
-            PlaylistTrack playlistTrack1 = optionalPlaylistTrack1.get();
-            PlaylistTrack playlistTrack2 = optionalPlaylistTrack2.get();
+            // given when
+            List<PlaylistTrack> playlistTracks = playlistTrackRepository.findAll();
+            List<PlaylistTrack> filteredPlaylistTracks0 = playlistTracks.stream()
+                    .filter(p -> p.getPlaylist().getTitle().equals("플레이리스트 제목0"))
+                    .toList();
+            List<PlaylistTrack> filteredPlaylistTracks1 = playlistTracks.stream()
+                    .filter(p -> p.getPlaylist().getTitle().equals("플레이리스트 제목1"))
+                    .toList();
 
             // then
-            assertThat(playlistTrack1.getPlaylist().getTitle()).isEqualTo("플레이리스트 제목0");
-            assertThat(playlistTrack2.getPlaylist().getTitle()).isEqualTo("플레이리스트 제목0");
-            assertThat(playlistTrack1.getPlaylist().getPlaylistImageUrl()).isEqualTo("https://test0.com");
-            assertThat(playlistTrack2.getPlaylist().getPlaylistImageUrl()).isEqualTo("https://test0.com");
-            assertThat(playlistTrack1.getTrack().getIsrc()).isEqualTo("isrc1");
-            assertThat(playlistTrack2.getTrack().getIsrc()).isEqualTo("isrc2");
-            assertThat(playlistTrack1.getOrderIndex()).isEqualTo(0);
-            assertThat(playlistTrack2.getOrderIndex()).isEqualTo(1);
-            assertThat(playlistTrack1.getPlaylist().getId()).isEqualTo(playlistIds.get(0));
-            assertThat(playlistTrack2.getPlaylist().getId()).isEqualTo(playlistIds.get(1));
+            assertThat(filteredPlaylistTracks0).hasSize(3);
+            assertThat(filteredPlaylistTracks0).allSatisfy(pt -> {
+                assertThat(pt.getPlaylist().getTitle()).isEqualTo("플레이리스트 제목0");
+                assertThat(pt.getPlaylist().getPlaylistImageUrl()).isEqualTo("https://test0.com");
+                assertThat(pt.getTrack().getIsrc()).isIn("isrc1", "isrc2", "isrc3");
+                assertThat(pt.getOrderIndex()).isIn(0, 1, 2);
+            });
+
+            assertThat(filteredPlaylistTracks1).hasSize(3);
+            assertThat(filteredPlaylistTracks1).allSatisfy(pt -> {
+                assertThat(pt.getPlaylist().getTitle()).isEqualTo("플레이리스트 제목1");
+                assertThat(pt.getPlaylist().getPlaylistImageUrl()).isEqualTo("https://test1.com");
+                assertThat(pt.getTrack().getIsrc()).isIn("isrc4", "isrc5", "isrc6");
+                assertThat(pt.getOrderIndex()).isIn(0, 1, 2);
+            });
         }
     }