public static async Task LinkSpotifyAsync( SpotifyLinkUploadModel spotifyLinkUploadModel, Guid userId, IRepositoryManager repositoryManager, SpotifyAPICredentials spotifyAPICredentials) { try { var user = await repositoryManager.UserRepository.GetByIdAsync(userId); if (user != null) { var spotifyAuthRequest = new AuthorizationCodeTokenRequest ( spotifyAPICredentials.ClientId, spotifyAPICredentials.ClientSecret, spotifyLinkUploadModel.Code, new Uri($"https://{spotifyLinkUploadModel.CallbackUrl}/callback") ); var spotifyAuthResponse = await new OAuthClient().RequestToken(spotifyAuthRequest); var spotifyToken = spotifyAuthResponse.AccessToken; var httpClient = new HttpClient(); var spotifyUserRequest = new HttpRequestMessage(new HttpMethod("GET"), "https://api.spotify.com/v1/me"); spotifyUserRequest.Headers.TryAddWithoutValidation("Authorization", $"Bearer {spotifyToken}"); var response = await httpClient.SendAsync(spotifyUserRequest); var responseString = await response.Content.ReadAsStringAsync(); var spotifyUserResponse = JsonConvert.DeserializeObject <SpotifyUserResponse>(responseString); var userImages = new List <UserImage>(); foreach (var image in spotifyUserResponse.Images) { userImages.Add(new UserImage { UserId = user.Id, Width = image.Width != null ? (short)image.Width : null, Height = image.Height != null ? (short)image.Height : null, Url = image.Uri }); } user.SpotifyRefreshToken = EncryptionService.EncryptString(spotifyAuthResponse.RefreshToken); user.SpotifyUsername = spotifyUserResponse.Id; user.SpotifyMarket = spotifyUserResponse.Country; user.UserImages = userImages; user.LastUpdatedOn = DateTime.Now; user.LastUpdatedBy = userId; await repositoryManager.UserRepository.UpdateAsync(user); } } catch (Exception) { throw; } }
public static async Task <SearchResponse> PerformAlbumSearch( string name, SpotifyAPICredentials spotifyAPICredentials, bool retryDueToException = false) { SearchResponse search; try { var spotify = SearchHelper.CreateSpotifyClient(spotifyAPICredentials); search = await spotify.Search.Item(new SearchRequest(SearchRequest.Types.Album, name) { Limit = 10, Offset = 0, Market = "IE" }); return(search); } catch (Exception err) { if (!retryDueToException) { return(await PerformAlbumSearch(name, spotifyAPICredentials, true).ConfigureAwait(false)); } else { if (err is APIException) { Console.Out.WriteLine("Failure due to Spotify API"); } throw; } } }
public static async Task <List <Track> > IndexNewAlbumTracksAsync( Guid albumId, FullAlbum album, IEnumerable <Artist> albumArtists, IRepositoryManager repositoryManager, IMapper mapper, SpotifyAPICredentials spotifyAPICredentials) { List <Track> newAlbumTracks = new List <Track>(); HashSet <string> albumArtistsSpotifyIds = albumArtists.Select(a => a.SpotifyId).ToHashSet(); foreach (var track in album.Tracks.Items) { var newTrack = new Track { SpotifyId = track.Id, AlbumId = albumId, Name = track.Name, TrackNumber = (short)track.TrackNumber, DiscNumber = (byte)track.DiscNumber, Duration = track.DurationMs }; newTrack.TrackArtists = await MapTrackArtistsAsync( track, albumArtistsSpotifyIds, albumArtists, repositoryManager, mapper, spotifyAPICredentials).ConfigureAwait(false); } return(newAlbumTracks); }
public ArtistController(ShuflContext shuflContext, ILogger <ArtistController> logger, IMapper mapper, IOptions <SpotifyAPICredentials> spotifyAPICredentials) : base(shuflContext, logger, mapper) { _spotifyAPICredentials = spotifyAPICredentials.Value; }
public static async Task <Playlist> IndexNewPlaylistAsync( string playlistIdentifier, Guid userId, IRepositoryManager repositoryManager, IMapper mapper, SpotifyAPICredentials spotifyAPICredentials) { var spotifyPlaylist = await FetchPlaylistForIndexAsync(playlistIdentifier, spotifyAPICredentials).ConfigureAwait(false); var newPlaylist = new Playlist { SpotifyId = spotifyPlaylist.Id, Name = spotifyPlaylist.Name, CreatedOn = DateTime.Now, CreatedBy = userId, LastUpdatedOn = DateTime.Now, LastUpdatedBy = userId }; newPlaylist.PlaylistImages = mapper.Map <List <PlaylistImage> >(spotifyPlaylist.Images); await repositoryManager.PlaylistRepository.AddAsync(newPlaylist); return(newPlaylist); }
public GroupAlbumController(ShuflContext dbContext, IMapper mapper, ILogger <GroupAlbumController> logger, IOptions <SpotifyAPICredentials> spotifyAPICredentials) : base(dbContext, logger, mapper) { _spotifyAPICredentials = spotifyAPICredentials.Value; }
public static async Task <AlbumResponseModel> FetchRandomTrackAsync(SpotifyAPICredentials spotifyAPICredentials, string genre = "") { var album = await AlbumModel.FetchRandomAlbumAsync(spotifyAPICredentials, genre).ConfigureAwait(false); album.Album.Tracks.Items = GetRandomTrack(album.Album.Tracks.Items); return(album); }
public static SpotifyClient CreateSpotifyClient(SpotifyAPICredentials spotifyAPICredentials) { var config = SpotifyClientConfig .CreateDefault() .WithAuthenticator(new ClientCredentialsAuthenticator(spotifyAPICredentials.ClientId, spotifyAPICredentials.ClientSecret)); return(new SpotifyClient(config)); }
public static async Task <FullArtist> FetchArtistAsync(string artistId, SpotifyAPICredentials spotifyAPICredentials) { var spotifyClient = SearchHelper.CreateSpotifyClient(spotifyAPICredentials); var artist = await spotifyClient.Artists.Get(artistId); return(artist); }
private static async Task <FullPlaylist> FetchPlaylistForIndexAsync( string playlistIdentifier, SpotifyAPICredentials spotifyAPICredentials) { var spotifyClient = SearchHelper.CreateSpotifyClient(spotifyAPICredentials); var playlist = await spotifyClient.Playlists.Get(playlistIdentifier); return(playlist); }
public static async Task QueueAlbumAsync( string albumId, Guid userId, IRepositoryManager repositoryManager, SpotifyAPICredentials spotifyAPICredentials) { try { var user = await repositoryManager.UserRepository.GetByIdAsync(userId); if (user != null) { if (user.SpotifyRefreshToken != null) { var spotifyAuthRefreshRequest = new AuthorizationCodeRefreshRequest ( spotifyAPICredentials.ClientId, spotifyAPICredentials.ClientSecret, DecryptionService.DecryptString(user.SpotifyRefreshToken) ); var spotifyAuthResponse = await new OAuthClient().RequestToken(spotifyAuthRefreshRequest); var spotifyToken = spotifyAuthResponse.AccessToken; var spotifyClient = new SpotifyClient(spotifyToken); var activeDevices = await spotifyClient.Player.GetAvailableDevices(); if (activeDevices.Devices.Count > 0) { var album = await spotifyClient.Albums.Get(albumId); foreach (var track in album.Tracks.Items) { var trackQueueRequest = new PlayerAddToQueueRequest(track.Uri); await spotifyClient.Player.AddToQueue(trackQueueRequest); } } else { throw new SpotifyNoActiveDevicesException("No Active Devices Found", "No Active Devices Found"); } } else { throw new SpotifyNotLinkedException("Spotify Account not Linked", "Spotify Account not Linked"); } } } catch (Exception) { throw; } }
public static async Task <SearchResponse> PerformRandomSearch( SearchRequest.Types type, SpotifyAPICredentials spotifyAPICredentials, string genre = "") { var buildSearchQueryResult = BuildSearchQuery(genre); var searchQuery = buildSearchQueryResult; var offset = RandInt(0, 999); return(await PerformSearch(type, searchQuery, 50, offset, spotifyAPICredentials).ConfigureAwait(false)); }
public static async Task <List <FullArtist> > FetchArtistsAsync( List <string> artistsIds, SpotifyAPICredentials spotifyAPICredentials) { var spotifyClient = SearchHelper.CreateSpotifyClient(spotifyAPICredentials); var artistsRequest = new ArtistsRequest(artistsIds.Take(50).ToList()); var artists = (await spotifyClient.Artists.GetSeveral(artistsRequest)).Artists; return(artists); }
public static async Task <FullArtist> FetchRandomArtistAsync(SpotifyAPICredentials spotifyAPICredentials, string genre = "") { var rand = new Random(); var searchGenre = string.IsNullOrWhiteSpace(genre) ? SearchConsts.SearchGenres[rand.Next(0, SearchConsts.SearchGenres.Count - 1)] : genre; var artists = await SearchHelper.PerformRandomSearch(SearchRequest.Types.Artist, spotifyAPICredentials, searchGenre); var artist = SelectRandomArtist(artists.Artists.Items); return(artist); }
public static async Task <Album> IndexNewAlbumAsync( string albumIdentifier, IRepositoryManager repositoryManager, IMapper mapper, SpotifyAPICredentials spotifyAPICredentials) { try { var spotifyAlbumDownloadModel = await FetchAlbumForIndexAsync(albumIdentifier, spotifyAPICredentials).ConfigureAwait(false); var artists = await ArtistModel.CreateOrFetchArtistAsync(spotifyAlbumDownloadModel.Artists, repositoryManager, mapper); var albumArtists = artists.Select(a => a.Id); var releaseDate = ReleaseDateParsingHelper.ParseReleaseDateToDateTime( spotifyAlbumDownloadModel.Album.ReleaseDate, spotifyAlbumDownloadModel.Album.ReleaseDatePrecision); var newAlbum = new Album { SpotifyId = spotifyAlbumDownloadModel.Album.Id, Name = spotifyAlbumDownloadModel.Album.Name, ReleaseDate = releaseDate, Type = (byte)MapAlbumTypeToEnum(spotifyAlbumDownloadModel.Album.Type), CreatedOn = DateTime.Now, LastUpdatedOn = DateTime.Now }; newAlbum.AlbumArtists = MapArtistsToAlbumArtists(albumArtists); newAlbum.AlbumImages = mapper.Map <List <AlbumImage> >(spotifyAlbumDownloadModel.Album.Images); await repositoryManager.AlbumRepository.AddAsync(newAlbum); /*var newAlbumTracks = await TrackModel.IndexNewAlbumTracksAsync( * newAlbum.Id, * spotifyAlbumDownloadModel.Album, * artists, * repositoryManager, * mapper, * spotifyAPICredentials); * * await repositoryManager.TrackRepository.AddRangeAsync(newAlbumTracks);*/ return(newAlbum); } catch (Exception) { throw; } }
public static async Task <AlbumResponseModel> FetchRandomAlbumAsync(SpotifyAPICredentials spotifyAPICredentials, string genre = "") { var randomArtist = await ArtistModel.FetchRandomArtistAsync(spotifyAPICredentials, genre); var randomArtistAlbums = await FetchArtistAlbumsAsync(randomArtist.Id, spotifyAPICredentials).ConfigureAwait(false); if (randomArtistAlbums.Count > 0) { randomArtistAlbums.Shuffle(); var randomAlbum = GetRandomAlbum(randomArtistAlbums); return(await FetchAlbumAsync(randomAlbum.Id, spotifyAPICredentials).ConfigureAwait(false)); } else { return(await FetchRandomAlbumAsync(spotifyAPICredentials, genre).ConfigureAwait(false)); } }
public static async Task <IEnumerable <SimplePlaylist> > GetUserPlaylistsAsync( SpotifyAPICredentials spotifyAPICredentials, Guid userId, int page, int pageSize, IRepositoryManager repositoryManager) { try { var user = await repositoryManager.UserRepository.GetByIdAsync(userId); if (user.SpotifyRefreshToken != null) { var spotifyAuthRefreshRequest = new AuthorizationCodeRefreshRequest ( spotifyAPICredentials.ClientId, spotifyAPICredentials.ClientSecret, DecryptionService.DecryptString(user.SpotifyRefreshToken) ); var spotifyAuthResponse = await new OAuthClient().RequestToken(spotifyAuthRefreshRequest); var spotifyToken = spotifyAuthResponse.AccessToken; var spotifyClient = new SpotifyClient(spotifyToken); var playlistsRequest = new PlaylistCurrentUsersRequest { Limit = pageSize, Offset = page * pageSize }; var playlists = await spotifyClient.Playlists.CurrentUsers(playlistsRequest); return(playlists.Items); } else { throw new SpotifyNotLinkedException("Spotify Account not Linked", "Spotify Account not Linked"); } } catch (Exception) { throw; } }
private static async Task <SpotifyAlbumDownloadModel> FetchAlbumForIndexAsync( string albumIdentifier, SpotifyAPICredentials spotifyAPICredentials) { var spotifyClient = SearchHelper.CreateSpotifyClient(spotifyAPICredentials); var album = await spotifyClient.Albums.Get(albumIdentifier); var artists = await ArtistModel.FetchArtistsAsync(album.Artists.Select(a => a.Id).ToList(), spotifyAPICredentials); var spotifyAlbumDownloadModel = new SpotifyAlbumDownloadModel { Artists = artists, Album = album }; return(spotifyAlbumDownloadModel); }
private static async Task <List <TrackArtist> > MapTrackArtistsAsync( SimpleTrack track, HashSet <string> albumArtistsSpotifyIds, IEnumerable <Artist> albumArtists, IRepositoryManager repositoryManager, IMapper mapper, SpotifyAPICredentials spotifyAPICredentials) { List <TrackArtist> trackArtists = new List <TrackArtist>(); List <string> trackArtistsToBeCreated = new List <string>(); var trackArtistSpotifyIds = track.Artists.Select(a => a.Id).ToHashSet(); foreach (var trackArtist in track.Artists) { if (albumArtistsSpotifyIds.Contains(trackArtist.Id)) { var albumArtist = albumArtists.Where(a => a.SpotifyId == trackArtist.Id).FirstOrDefault(); trackArtists.Add(new TrackArtist { ArtistId = albumArtist.Id, CreatedOn = DateTime.Now, LastUpdatedOn = DateTime.Now }); } else { trackArtistsToBeCreated.Add(trackArtist.Id); } } if (trackArtistsToBeCreated.Count > 0) { var newArtists = await ArtistModel.FetchArtistsAsync(trackArtistsToBeCreated, spotifyAPICredentials); var artists = await ArtistModel.CreateOrFetchArtistAsync(newArtists, repositoryManager, mapper); trackArtists.AddRange(MapArtistsToTrackArtists(artists.Select(a => a.Id).ToList())); } return(trackArtists); }
public static async Task <SearchResponse> PerformSearch( SearchRequest.Types type, string searchQuery, int limit, int offset, SpotifyAPICredentials spotifyAPICredentials, bool retryDueToException = false, int retry = 0) { SearchResponse search; try { var spotify = CreateSpotifyClient(spotifyAPICredentials); search = await spotify.Search.Item(new SearchRequest(type, searchQuery) { Limit = limit, Offset = offset }); } catch (Exception err) { if (!retryDueToException) { return(await PerformSearch( type, searchQuery, limit, offset, spotifyAPICredentials, true).ConfigureAwait(false)); } else { if (err is APIException) { Console.Out.WriteLine("Failure due to Spotify API"); } throw; } } if (!IsValidSearchResponse(type, search)) { if (retry == 5 || offset < limit) { return(search); } else { retry++; offset = (int)(offset * (0.1f * retry)); return(await PerformSearch( type, searchQuery, limit, offset, spotifyAPICredentials, retry : retry).ConfigureAwait(false)); } } return(search); }
public static async Task <AlbumResponseModel> FetchTrackAsync(string trackId, SpotifyAPICredentials spotifyAPICredentials) { var spotifyClient = SearchHelper.CreateSpotifyClient(spotifyAPICredentials); var track = await spotifyClient.Tracks.Get(trackId); var album = await AlbumModel.FetchAlbumAsync(track.Album.Id, spotifyAPICredentials).ConfigureAwait(false); album.Album.Tracks.Items = GetTrack(album.Album.Tracks.Items, trackId); return(album); }
public static async Task <List <SimpleAlbum> > FetchArtistAlbumsAsync(string artistId, SpotifyAPICredentials spotifyAPICredentials) { var spotifyClient = SearchHelper.CreateSpotifyClient(spotifyAPICredentials); var albumsRequest = new ArtistsAlbumsRequest { Market = "IE", Limit = 50 }; var albums = (await spotifyClient.Artists.GetAlbums(artistId, albumsRequest)).Items; return(albums); }
public static async Task <AlbumResponseModel> FetchAlbumAsync(string albumIdentifier, SpotifyAPICredentials spotifyAPICredentials) { var spotifyClient = SearchHelper.CreateSpotifyClient(spotifyAPICredentials); var album = await spotifyClient.Albums.Get(albumIdentifier); var artistsRequest = new ArtistsRequest(album.Artists.Select(a => a.Id).ToList()); var artists = await spotifyClient.Artists.GetSeveral(artistsRequest); var albumResponseModel = new AlbumResponseModel { Album = album, Artists = artists.Artists }; return(albumResponseModel); }
public static async Task <string> CreateNewGroupPlaylistAsync( GroupPlaylistUploadModel groupPlaylistUploadModel, Guid userId, IRepositoryManager repositoryManager, IMapper mapper, SpotifyAPICredentials spotifyAPICredentials) { var groupIdentifier = groupPlaylistUploadModel.GroupIdentifier.ToUpperInvariant(); try { var group = await repositoryManager.GroupRepository.GetByIdentifierAsync(groupIdentifier); if (group != null) { var isUserMemberOfGroup = await GroupMemberModel.CheckGroupMemberExistsAsync( groupPlaylistUploadModel.GroupIdentifier, userId, repositoryManager); if (isUserMemberOfGroup) { var newGroupPlaylistIdentifier = await GenerateNewGroupPlaylistIdentifierAsync( group.Id, repositoryManager.GroupPlaylistRepository).ConfigureAwait(false); var newGroupPlaylist = new GroupPlaylist { GroupId = group.Id, Identifier = newGroupPlaylistIdentifier, CreatedOn = DateTime.Now, CreatedBy = userId, LastUpdatedOn = DateTime.Now, LastUpdatedBy = userId }; var existingPlaylist = await repositoryManager.PlaylistRepository.CheckExistsBySpotifyIdAsync( groupPlaylistUploadModel.PlaylistIdentifier); if (existingPlaylist != null) { newGroupPlaylist.PlaylistId = existingPlaylist.Id; } else { var newPlaylist = await PlaylistModel.IndexNewPlaylistAsync( groupPlaylistUploadModel.PlaylistIdentifier, userId, repositoryManager, mapper, spotifyAPICredentials); newGroupPlaylist.PlaylistId = newPlaylist.Id; } await repositoryManager.GroupPlaylistRepository.AddAsync(newGroupPlaylist); return(newGroupPlaylistIdentifier); } else { throw new UserNotGroupMemberException( "You are not able to perform this action", "You are not able to perform this action"); } } else { throw new InvalidTokenException(InvalidTokenType.TokenNotFound, "The requested Group was not found"); } } catch (Exception) { throw; } }