public static async Task <Song> AddSongToQuiz(SpotifyTokens token, string href)
{
Track newTrack;
string albumDate;
newTrack = await SpotifyManager.GetOneSong(token, href);
albumDate = await SpotifyManager.GetOneAlbum(token, newTrack.Album.Href);
StringBuilder builder = new StringBuilder();
foreach (var artist in newTrack.Artists)
{
builder.Append(artist.Name);
if (artist != newTrack.Artists[newTrack.Artists.Count - 1])
{
builder.Append(", ");
}
}
var newSong = new Song
{
Artist = builder.ToString(),
Title = newTrack.Name,
RealeaseDate = albumDate,
AlbumTitle = newTrack.Album.Name,
SpotifyReferenceID = newTrack.Href,
PreviewUrl = newTrack.PreviewUrl
};
return(newSong);
}
private async Task <string> CreateToken(SpotifyTokens spotifyTokens)
{
_spotifyService.AccessToken = spotifyTokens.AccessToken;
var me = await _spotifyService.GetMeAsync();
var claims = new[]
{
new Claim("spotifyAccessToken", spotifyTokens.AccessToken),
new Claim("spotifyRefreshToken", spotifyTokens.RefreshToken),
new Claim("spotifyUserId", me.Id),
new Claim("spotifyUserDisplayName", me.DisplayName),
new Claim("spotifyUserImageUrl", me.Images.FirstOrDefault()?.Url ?? ""),
};
var jwtSettings = _configuration.GetSection("Jwt").Get <JwtSettings>();
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(jwtSettings.Secret));
var credentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var jwtToken = new JwtSecurityToken(
jwtSettings.Issuer,
jwtSettings.Audience,
claims,
expires: DateTime.UtcNow.AddSeconds(spotifyTokens.ExpiresIn),
signingCredentials: credentials
);
return(new JwtSecurityTokenHandler().WriteToken(jwtToken));
}
public static IEnumerable <Track> GetTracksFromPlaylist(Playlist playlist, SpotifyTokens spotifyTokens)
{
if (playlist == null || playlist.Owner == null || playlist.Owner.Id == null || playlist.Id == null)
{
yield break;
}
var client = GetClient();
client.Headers.Add("Authorization", "Bearer " + spotifyTokens.AccessToken);
PlaylistTracksResponse deserialized = null;
var url = string.Format(Constants.SpotifyUrls.SpotifyGetTracksFromPlaylistUrl, playlist.Owner.Id, playlist.Id);
var result = client.DownloadString(url);
deserialized = Newtonsoft.Json.JsonConvert.DeserializeObject <PlaylistTracksResponse>(result);
if (deserialized != null)
{
foreach (var track in deserialized.Tracks)
{
yield return(track.Track);
}
}
}
public static SpotifyTokens GetSpotifyTokens(Controller controller)
{
var token = new SpotifyTokens(
controller.HttpContext.Session.GetString("access_token"),
controller.HttpContext.Session.GetString("refresh_token"),
controller.HttpContext.Session.GetString("timestamp"),
controller.User.Identity.Name
);
return(token);
}
public static SpotifyUser GetAuthenticatedUser(SpotifyTokens spotifyTokens)
{
var client = GetClient();
client.Headers.Add("Authorization", "Bearer " + spotifyTokens.AccessToken);
var result = client.DownloadString(Constants.SpotifyUrls.SpotifyMeUrl);
var deserialized = Newtonsoft.Json.JsonConvert.DeserializeObject <SpotifyUser>(result);
return(deserialized);
}
public static async Task RemoveSongFromQuiz(SpotifyTokens token, int indexToRemove)
{
string currentQuizJson;
Quiz currentQuiz;
currentQuizJson = await MongoManager.GetQuizFromSession(token.Username);
currentQuiz = JsonConvert.DeserializeObject <Quiz>(currentQuizJson);
currentQuiz.Songs.RemoveAt(indexToRemove);
currentQuizJson = JsonConvert.SerializeObject(currentQuiz);
await MongoManager.SaveQuizToSession(currentQuizJson, token.Username);
}
public static async Task <List <PlaylistVM> > GetPlaylists(SpotifyTokens token)
{
ListOfPlaylists allReturnedPlaylists;
allReturnedPlaylists = await SpotifyManager.GetAllUserPlaylists(token);
var playlists = new List <PlaylistVM>();
foreach (var item in allReturnedPlaylists.Items)
{
playlists.Add(new PlaylistVM(item.Name, item.Tracks.Href));
}
return(playlists);
}
public static async Task <bool> ExportPlaylistAsync(SpotifyTokens token, string quizId)
{
bool createResult = false;
var quizToExport = JsonConvert.DeserializeObject <Quiz>(await MongoManager.GetOneQuizAsync(quizId, "Quizzes"));
var playlistName = quizToExport.Name;
// Check if it already exists, in that case warn user? Replace all songs?
// The way this works now is that a new playlist is created with the same name if it already exists.
//var listOfPlaylists = await SpotifyManager.GetAllUserPlaylists(token);
//bool playlistExists = false;
//foreach (var item in listOfPlaylists.Items)
//{
// if (item.Name == playlistName)
// {
// playlistExists = true;
// break;
// }
//}
if (true /*!playlistExists*/)
{
// Create a new spotifyPlaylist with the chosen name if it does not exist.
// In SpotifyManager.
var newPlaylistId = await SpotifyManager.CreateNewPlaylistAsync(token, playlistName);
// Add tracks to the newly created playlist.
// In SpotifyManager.
StringBuilder tracks = new StringBuilder();
foreach (var song in quizToExport.Songs)
{
tracks.Append("spotify:track:" + song.SpotifyReferenceID);
if (song != quizToExport.Songs[quizToExport.Songs.Count - 1])
{
tracks.Append(",");
}
}
var tracksAddResult = SpotifyManager.AddTracksToPlaylist(token, newPlaylistId, tracks.ToString());
if (tracksAddResult == "Created")
{
createResult = true;
await MongoManager.UpdateSpotifyPlaylistRefAsync(quizId, newPlaylistId);
}
}
return(createResult);
}
public static async Task <Quiz> GenerateQuiz(SpotifyTokens token, PlaylistVM viewModel)
{
ListOfSongs allReturnedSongs;
allReturnedSongs = await SpotifyManager.GetAllSongsFromPlaylist(token, viewModel.SpotifyRef);
var quiz = new Quiz();
quiz._id = Guid.NewGuid().ToString();
quiz.Name = viewModel.Name;
quiz.PlaylistRef = viewModel.SpotifyRef;
quiz.Owner = token.Username;
int counter = 0;
foreach (var item in allReturnedSongs.Items)
{
StringBuilder builder = new StringBuilder();
foreach (var artist in item.Track.Artists)
{
builder.Append(artist.Name);
if (artist != item.Track.Artists[item.Track.Artists.Count - 1])
{
builder.Append(", ");
}
}
quiz.Songs.Add(new Song
{
Title = item.Track.Name,
Artist = builder.ToString(),
AlbumTitle = item.Track.Album.Name,
RealeaseDate = allReturnedSongs.AlbumInfo.AlbumInfo[counter].ReleaseDate,
SpotifyReferenceID = item.Track.Href,
PreviewUrl = item.Track.PreviewUrl
});
counter++;
}
return(quiz);
}
public static Playlist CreatePlayList(SpotifyTokens spotifyTokens, string userId, string listName)
{
var client = GetClient();
client.Headers.Add("Authorization", "Bearer " + spotifyTokens.AccessToken);
client.Headers.Add("Content-Type", "application/json");
var request = new CreatePlaylistRequest
{
Name = listName,
Public = true
};
var serializedRequest = JsonConvert.SerializeObject(request);
var urlToCall = string.Format(Constants.SpotifyUrls.SpotifyUsersPlaylistsUrlWithPlaceholder, userId);
var result = client.UploadString(urlToCall, serializedRequest);
var deserialized = Newtonsoft.Json.JsonConvert.DeserializeObject <Playlist>(result);
return(deserialized);
}
public static SpotifyTokens RenewSpotifyTokens(SpotifyTokens oldTokens)
{
var client = GetClient();
NameValueCollection values = new NameValueCollection();
values.Add("grant_type", "refresh_token");
values.Add("refresh_token", oldTokens.RefreshToken);
var idAndSecret = WebConfigurationManager.AppSettings[Constants.ConfigurationKeys.SpotifyClientId] + ":" +
WebConfigurationManager.AppSettings[Constants.ConfigurationKeys.SpotifyClientSecret];
client.Headers.Add("Authorization", "Basic " + Base64Encode(idAndSecret));
var result = client.UploadValues(new Uri("https://accounts.spotify.com/api/token"), values);
string decoded = client.Encoding.GetString(result);
var deserialized = Newtonsoft.Json.JsonConvert.DeserializeObject <SpotifyTokens>(decoded);
deserialized.RefreshToken = oldTokens.RefreshToken;
deserialized.ReceivedTime = DateTime.UtcNow;
return(deserialized);
}
