add overflow and batch feature extraction call

frontend/src/components/SongTable.tsx

@@ -293,6 +293,7 @@ const SongTable: React.FC<SongTableProps> = ({
           borderBottom: "1px solid #333",
           py: 1,
           px: 2,
+          overflowY: "auto",
         }}
       >
         <Box sx={{ width: "30px", mr: 1 }}></Box>

spring-boot-app/src/main/java/com/nexttrack/spring_boot_app/Services/NextTrackAudioFeaturesService.java

@@ -1,5 +1,7 @@
 package com.nexttrack.spring_boot_app.Services;
 
+import com.nexttrack.spring_boot_app.Services.NextTrackAudioFeaturesService.AudioFeaturesResponse;
+import com.nexttrack.spring_boot_app.Services.NextTrackAudioFeaturesService.TrackKey;
 import com.nexttrack.spring_boot_app.model.NextTrackAudioFeatures;
 import com.nexttrack.spring_boot_app.repository.NextTrackAudioFeaturesRepo;
 
@@ -8,15 +10,22 @@
 import org.springframework.stereotype.Service;
 import org.springframework.web.reactive.function.client.WebClient;
 
+import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import com.fasterxml.jackson.databind.ObjectMapper;
 
 @Service
 public class NextTrackAudioFeaturesService {
 
     private final NextTrackAudioFeaturesRepo nextTrackAudioFeaturesRepo;
     private final WebClient webClient;
 
+    public record TrackKey(String name, String artist) {
+    }
+
     public NextTrackAudioFeaturesService(NextTrackAudioFeaturesRepo nextTrackAudioFeaturesRepo) {
         this.nextTrackAudioFeaturesRepo = nextTrackAudioFeaturesRepo;
         this.webClient = WebClient.builder()
@@ -57,6 +66,68 @@ public NextTrackAudioFeatures findOrCreateTrack(String name, String artist) {
                 });
     }
 
+    public Map<TrackKey, NextTrackAudioFeatures> batchFindOrCreate(List<TrackKey> keys) {
+        List<NextTrackAudioFeatures> existing = nextTrackAudioFeaturesRepo
+                .findAllByNameAndArtistIn(keys);
+
+        // TODO: optimize retreival of existing tracks
+        Map<TrackKey, NextTrackAudioFeatures> map = existing.stream()
+                .collect(Collectors.toMap(
+                        e -> new TrackKey(e.getName(), e.getArtist()),
+                        Function.identity(),
+                        (existingValue, duplicateValue) -> existingValue));
+        List<TrackKey> missing = keys.stream()
+                .filter(k -> !map.containsKey(k))
+                .toList();
+
+        if (!missing.isEmpty()) {
+            try {
+                List<Map<String, String>> tracksList = missing.stream()
+                        .map(k -> Map.of("track_name", k.name, "artist", k.artist))
+                        .toList();
+
+                Map<String, Object> payload = Map.of("tracks", tracksList);
+                // System.out.println("Sending payload: " + new
+                // ObjectMapper().writeValueAsString(payload));
+
+                List<AudioFeaturesResponse> responses = webClient.post()
+                        .uri("https://feature-extraction-service-production.up.railway.app/extract_features_batch")
+                        .bodyValue(payload)
+                        .retrieve()
+                        .bodyToFlux(AudioFeaturesResponse.class)
+                        .collectList()
+                        .block();
+
+                List<NextTrackAudioFeatures> toSave = responses.stream().map(r -> {
+                    var f = r.getFeatures();
+                    NextTrackAudioFeatures e = new NextTrackAudioFeatures();
+                    e.setName(r.getTrack().split(" - ")[0]); // track format is "name - artist"
+                    e.setArtist(r.getTrack().split(" - ")[1]);
+                    e.setAcousticness(f.getAcousticness());
+                    e.setDanceability(f.getDanceability());
+                    e.setEnergy(f.getEnergy());
+                    e.setInstrumentalness(f.getInstrumentalness());
+                    e.setKey(f.getKey());
+                    e.setLiveness(f.getLiveness());
+                    e.setLoudness(f.getLoudness());
+                    e.setSpeechiness(f.getSpeechiness());
+                    e.setTempo(f.getTempo());
+                    e.setValence(f.getValence());
+                    return e;
+                }).toList();
+
+                List<NextTrackAudioFeatures> saved = nextTrackAudioFeaturesRepo.saveAll(toSave);
+
+                saved.forEach(e -> map.put(new TrackKey(e.getName(), e.getArtist()), e));
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+
+        }
+
+        return map;
+    }
+
     public static class AudioFeaturesResponse {
         private Features features;
         private String track;

spring-boot-app/src/main/java/com/nexttrack/spring_boot_app/Services/ReshuffleService.java

@@ -37,7 +37,8 @@ public List<NextTrack> reshuffle(String email, Map<String, NextTrack> songInfoMa
 
             PlaylistReshuffleMLRequest request = new PlaylistReshuffleMLRequest(email, songDetailsList);
 
-            System.out.println("Sending payload: " + new ObjectMapper().writeValueAsString(request));
+            // System.out.println("Sending payload: " + new
+            // ObjectMapper().writeValueAsString(request));
             return webClient.post()
                     .uri("/shuffle")
                     .bodyValue(request)

spring-boot-app/src/main/java/com/nexttrack/spring_boot_app/Services/SpotifyService.java

@@ -18,6 +18,7 @@
 import se.michaelthelin.spotify.model_objects.specification.PlaylistTrack;
 import se.michaelthelin.spotify.model_objects.specification.Track;
 import se.michaelthelin.spotify.model_objects.specification.User;
+import se.michaelthelin.spotify.requests.authorization.authorization_code.AuthorizationCodeRefreshRequest;
 import se.michaelthelin.spotify.requests.authorization.authorization_code.AuthorizationCodeRequest;
 import se.michaelthelin.spotify.requests.authorization.authorization_code.AuthorizationCodeUriRequest;
 import se.michaelthelin.spotify.requests.data.personalization.simplified.GetUsersTopArtistsRequest;
@@ -78,13 +79,17 @@ public String getTokens(String code) {
 
     public void refreshAccessToken() {
         try {
-            AuthorizationCodeCredentials credentials = spotifyApi.authorizationCodeRefresh().build().execute();
-            spotifyApi.setAccessToken(credentials.getAccessToken());
-            if (credentials.getRefreshToken() != null) {
-                spotifyApi.setRefreshToken(credentials.getRefreshToken());
+            AuthorizationCodeRefreshRequest refreshRequest = spotifyApi.authorizationCodeRefresh()
+                    .refresh_token(spotifyApi.getRefreshToken())
+                    .build();
+
+            AuthorizationCodeCredentials creds = refreshRequest.execute();
+            spotifyApi.setAccessToken(creds.getAccessToken());
+            if (creds.getRefreshToken() != null) {
+                spotifyApi.setRefreshToken(creds.getRefreshToken());
             }
-        } catch (Exception exception) {
-            System.out.println("Error refreshing access token: " + exception.getMessage());
+        } catch (Exception e) {
+            System.err.println("Error refreshing token: " + e.getMessage());
         }
     }
 

spring-boot-app/src/main/java/com/nexttrack/spring_boot_app/controller/PlaylistController.java

@@ -69,26 +69,23 @@ public PlaylistSimplified[] getAllRemixes(@PathVariable String email) {
 
     @GetMapping("playlist/{playlistId}")
     public List<NextTrack> getPlaylist(@PathVariable String playlistId) {
-        PlaylistTrack[] playlistTracks = spotifyService.getSongsFromPlaylist(playlistId);
-
-        // Extract track IDs
-        List<String> trackIds = Arrays.stream(playlistTracks)
+        PlaylistTrack[] items = spotifyService.getSongsFromPlaylist(playlistId);
+        List<String> ids = Arrays.stream(items)
                 .map(pt -> pt.getTrack().getId())
-                .collect(Collectors.toList());
+                .toList();
 
-        // Create a map of full track info keyed by track ID
-        Map<String, Track> fullTrackMap = new HashMap<>();
+        Map<String, Track> fullMap = new HashMap<>();
         int batchSize = 50;
 
-        for (int i = 0; i < trackIds.size(); i += batchSize) {
-            int end = Math.min(i + batchSize, trackIds.size());
-            List<String> batch = trackIds.subList(i, end);
+        for (int i = 0; i < ids.size(); i += batchSize) {
+            int end = Math.min(i + batchSize, ids.size());
+            List<String> batch = ids.subList(i, end);
 
             try {
                 List<Track> fullTracks = spotifyService.getSeveralTracks(batch);
 
                 for (Track track : fullTracks) {
-                    fullTrackMap.put(track.getId(), track);
+                    fullMap.put(track.getId(), track);
                 }
 
             } catch (Exception e) {
@@ -97,45 +94,51 @@ public List<NextTrack> getPlaylist(@PathVariable String playlistId) {
             }
         }
 
-        return Arrays.stream(playlistTracks).map(pt -> {
-            String id = pt.getTrack().getId();
-            Track full = fullTrackMap.get(id);
+        List<NextTrackAudioFeaturesService.TrackKey> keys = new ArrayList<>();
+        List<NextTrack> dtoList = new ArrayList<>();
 
+        for (PlaylistTrack pt : items) {
+            Track full = fullMap.get(pt.getTrack().getId());
             if (full == null)
-                return null;
-
-            String name = full.getName();
-
-            List<String> artistNames = Arrays.stream(full.getArtists())
-                    .map(ArtistSimplified::getName)
-                    .collect(Collectors.toList());
-
-            String uri = full.getUri();
-            int durationMs = full.getDurationMs();
+                continue;
+
+            NextTrack nt = new NextTrack(
+                    full.getId(),
+                    full.getName(),
+                    Arrays.stream(full.getArtists()).map(a -> a.getName()).toList(),
+                    full.getUri(),
+                    full.getAlbum() != null && full.getAlbum().getImages().length > 0
+                            ? full.getAlbum().getImages()[0].getUrl()
+                            : null,
+                    full.getDurationMs());
+            String artist = full.getArtists()[0].getName();
+            keys.add(new NextTrackAudioFeaturesService.TrackKey(full.getName(), artist));
+            dtoList.add(nt);
+        }
 
-            String albumCover = null;
-            if (full.getAlbum() != null && full.getAlbum().getImages().length > 0) {
-                albumCover = full.getAlbum().getImages()[0].getUrl();
+        Map<NextTrackAudioFeaturesService.TrackKey, NextTrackAudioFeatures> features = nextTrackAudioFeaturesService
+                .batchFindOrCreate(keys);
+
+        for (int i = 0; i < dtoList.size(); i++) {
+            NextTrack nt = dtoList.get(i);
+            var key = keys.get(i);
+            NextTrackAudioFeatures f = features.get(key);
+            if (f != null) {
+                nt.setDanceability(f.getDanceability());
+                nt.setEnergy(f.getEnergy());
+                nt.setKey(f.getKey());
+                nt.setLoudness(f.getLoudness());
+                nt.setMode(f.getMode());
+                nt.setSpeechiness(f.getSpeechiness());
+                nt.setAcousticness(f.getAcousticness());
+                nt.setInstrumentalness(f.getInstrumentalness());
+                nt.setLiveness(f.getLiveness());
+                nt.setValence(f.getValence());
+                nt.setTempo(f.getTempo());
             }
-            var track = new NextTrack(id, name, artistNames, uri, albumCover, durationMs);
-            NextTrackAudioFeatures audioFeatures = nextTrackAudioFeaturesService.findOrCreateTrack(name,
-                    artistNames.get(0));
-
-            track.setDanceability(audioFeatures.getDanceability());
-            track.setEnergy(audioFeatures.getEnergy());
-            track.setKey(audioFeatures.getKey());
-            track.setLoudness(audioFeatures.getLoudness());
-            track.setMode(audioFeatures.getMode());
-            track.setSpeechiness(audioFeatures.getSpeechiness());
-            track.setAcousticness(audioFeatures.getAcousticness());
-            track.setInstrumentalness(audioFeatures.getInstrumentalness());
-            track.setLiveness(audioFeatures.getLiveness());
-            track.setValence(audioFeatures.getValence());
-            track.setTempo(audioFeatures.getTempo());
-
-            return track;
-
-        }).filter(Objects::nonNull).collect(Collectors.toList());
+        }
+
+        return dtoList;
     }
 
     @PostMapping("playlist/reshuffle")

spring-boot-app/src/main/java/com/nexttrack/spring_boot_app/repository/NextTrackAudioFeaturesRepo.java

@@ -2,13 +2,20 @@
 
 import org.springframework.data.mongodb.repository.MongoRepository;
 import org.springframework.data.mongodb.repository.Query;
+import org.springframework.data.repository.query.Param;
+import org.springframework.data.util.Pair;
 
+import com.nexttrack.spring_boot_app.Services.NextTrackAudioFeaturesService.TrackKey;
 import com.nexttrack.spring_boot_app.model.NextTrackAudioFeatures;
 
+import java.util.List;
 import java.util.Optional;
 
 public interface NextTrackAudioFeaturesRepo extends MongoRepository<NextTrackAudioFeatures, String> {
 
     @Query("{ name: '?0', artist: '?1' }")
     Optional<NextTrackAudioFeatures> findByNameAndArtist(String name, String artist);
+
+    @Query("SELECT f FROM NextTrackAudioFeatures f WHERE (f.name,f.artist) IN :pairs")
+    List<NextTrackAudioFeatures> findAllByNameAndArtistIn(@Param("pairs") List<TrackKey> keys);
 }