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;
}
}
