public TrackInfo WhatIsNowPlaying() { DateTime expireDate = accessToken.CreateDate.AddSeconds(accessToken.ExpiresIn); if (DateTime.Compare(DateTime.Now, expireDate.AddMinutes(-1)) > 0) { accessToken = authorization.RefreshToken(refreshToken.RefreshToken).Result; webApi.AccessToken = accessToken.AccessToken; if (accessToken.RefreshToken != null) { refreshToken = accessToken; } } try { PlaybackContext context = webApi.GetPlayingTrack(); if (context.IsPlaying && !TrackType.Ad.Equals(context.CurrentlyPlayingType)) { FullTrack track = context.Item; return(new TrackInfo(track.Artists[0].Name, track.Name, track.Album.Images[0].Url)); } } catch (AggregateException) { } return(null); }
public async void refreshtoken(string codeToken, bool tellPeople, Action <bool, bool, string, string> callback = null) { initialized = false; if (_spotify == null) { _spotify = new SpotifyWebAPI(); } AuthorizationCodeAuth auth = getAuth(); Token token = await auth.RefreshToken(codeToken); _spotify.AccessToken = token.AccessToken; _spotify.TokenType = token.TokenType; if (!token.HasError()) { initialized = true; } else { Console.WriteLine(token.Error + " - " + token.ErrorDescription); } if (callback != null) { callback(initialized, tellPeople, token.AccessToken, token.RefreshToken); } }
/// <summary> /// <see cref="BaseMeasure.Update"/> /// </summary> /// <returns><see cref="BaseMeasure.Update"/></returns> internal override double Update() { if (_accessToken == null || _accessToken.IsExpired()) { var auth = new AuthorizationCodeAuth(_clientId, _clientSecret, string.Empty, string.Empty); var refresh = auth.RefreshToken(_refreshToken); if (!refresh.Wait(10000)) { _log(LogType.Error, "Timeout when refreshing token"); return(0); } _accessToken = refresh.Result; } var api = new SpotifyWebAPI { AccessToken = _accessToken.AccessToken, UseAuth = true, TokenType = _accessToken.TokenType, }; Playback = api.GetPlayback(); return(base.Update()); }
public CustomToken RefreshToken(string refreshToken, string clientSecret) { AuthorizationCodeAuth auth = new AuthorizationCodeAuth( Settings.ClientId, Settings.ClientSecret, Settings.RedirectUri, Settings.RedirectUri, Scope.None, Settings.StateKey ); Token response; CustomToken result = null; try { response = auth.RefreshToken(refreshToken).Result; result = response.ToCustomToken(); if (result != null) { result.RefreshToken = refreshToken; } } catch (Exception) { } return(result); }
public async Task ConnectWebApi(bool keepRefreshToken = true) { _securityStore = SecurityStore.Load(pluginDirectory); AuthorizationCodeAuth auth = new AuthorizationCodeAuth(_securityStore.ClientId, _securityStore.ClientSecret, "http://localhost:4002", "http://localhost:4002", Scope.PlaylistReadPrivate | Scope.PlaylistReadCollaborative | Scope.UserReadCurrentlyPlaying | Scope.UserReadPlaybackState | Scope.UserModifyPlaybackState | Scope.Streaming | Scope.UserFollowModify); if (_securityStore.HasRefreshToken && keepRefreshToken) { Token token = await auth.RefreshToken(_securityStore.RefreshToken); _spotifyApi = new SpotifyWebAPI() { TokenType = token.TokenType, AccessToken = token.AccessToken }; } else { auth.AuthReceived += async(sender, payload) => { auth.Stop(); Token token = await auth.ExchangeCode(payload.Code); _securityStore.RefreshToken = token.RefreshToken; _securityStore.Save(pluginDirectory); _spotifyApi = new SpotifyWebAPI() { TokenType = token.TokenType, AccessToken = token.AccessToken }; }; auth.Start(); auth.OpenBrowser(); } }
private async Task RefreshTokenAsync() { if (!_settings.Token.HasExpired()) { return; } UpdateToken(await _authentication.RefreshToken(_settings.Token.RefreshToken)); }
public void Authenticate() { Token newToken = auth.RefreshToken(token.RefreshToken).Result; api.TokenType = newToken.TokenType; api.AccessToken = newToken.AccessToken; App.Current.Properties["TokenType"] = api.TokenType; App.Current.Properties["AccessToken"] = api.AccessToken; }
public void RefrescarToken() { Log.Instance.ImprimirMensaje("Refrescando Token...", TipoMensaje.Info); Token newToken = auth.RefreshToken(CodigoRefresco).Result; _spotify.AccessToken = newToken.AccessToken; _spotify.TokenType = newToken.TokenType; tokenActual = newToken; Log.Instance.ImprimirMensaje("Token refrescado!", TipoMensaje.Correcto); }
internal SpotifyAuthentication() { bool initialized = false; var client_id = "7b2f38e47869431caeda389929a1908e"; var secret_id = "c3a86330ef844c16be6cb46d5e285a45"; _authenFactory = new AuthorizationCodeAuth( client_id, secret_id, "http://localhost:8800", "http://localhost:8800", Scope.UserReadCurrentlyPlaying | Scope.UserModifyPlaybackState | Scope.AppRemoteControl | Scope.UserReadPlaybackState ); _authenFactory.AuthReceived += async(s, p) => { var ath = (AuthorizationCodeAuth)s; ath.Stop(); var token = await ath.ExchangeCode(p.Code); _refreshToken = token.RefreshToken; if (_client == null) { _client = new SpotifyWebAPI() { AccessToken = token.AccessToken, TokenType = "Bearer" }; } else { _client.AccessToken = token.AccessToken; } if (!initialized) { ClientReady?.Invoke(this, _client); } initialized = true; }; _authenFactory.Start(); _authenFactory.OpenBrowser(); _refreshTokenWorker = new Timer(); _refreshTokenWorker.Interval = 30 * (1000 * 60); _refreshTokenWorker.Elapsed += async(s, e) => { var token = await _authenFactory.RefreshToken(_refreshToken); _client.AccessToken = token.AccessToken; }; _refreshTokenWorker.Start(); }
SpotifyConfiguration() { bool initialized = false; var client_id = "7b2f38e47869431caeda389929a1908e"; var secret_id = "c3a86330ef844c16be6cb46d5e285a45"; AuthenFactory = new AuthorizationCodeAuth( client_id, secret_id, "http://localhost:8888", "http://localhost:8888", SpotifyAPI.Web.Enums.Scope.AppRemoteControl ); AuthenFactory.AuthReceived += async(s, p) => { var ath = (AuthorizationCodeAuth)s; ath.Stop(); var token = await ath.ExchangeCode(p.Code); initialized = true; RefreshToken = token.RefreshToken; if (Client == null) { Client = new SpotifyWebAPI() { AccessToken = token.AccessToken, TokenType = "Bearer" }; } else { Client.AccessToken = token.AccessToken; } IsAvailable = true; }; AuthenFactory.Start(); AuthenFactory.OpenBrowser(); while (!initialized) { System.Threading.Thread.Sleep(1000); } AuthenFactory.Stop(); _refreshTokenWorker = new Timer(); _refreshTokenWorker.Interval = 30 * (1000 * 60); _refreshTokenWorker.Elapsed += async(s, e) => { var token = await AuthenFactory.RefreshToken(RefreshToken); Client.AccessToken = token.AccessToken; }; _refreshTokenWorker.Start(); }
static async Task RefreshToken(bool isSilent = false) { if (!isSilent) { Console.WriteLine(String.Format("\r{0,-80}", "Refreshing access token...")); } Token newToken = await auth.RefreshToken(token.RefreshToken); if (!newToken.HasError()) { spotifyAPI.AccessToken = newToken.AccessToken; spotifyAPI.TokenType = newToken.TokenType; token.AccessToken = newToken.AccessToken; token.ExpiresIn = newToken.ExpiresIn; token.CreateDate = newToken.CreateDate; if (!isSilent) { Console.WriteLine("New '" + token.TokenType + "' access token acquired at " + DateTime.Now); } SaveTokenToFile(isSilent); if (!isSilent) { Console.WriteLine(""); } } else { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("TOKEN ERROR"); Console.WriteLine("Error:\t\t" + newToken.Error); Console.WriteLine("Description:\t" + newToken.ErrorDescription); Console.ForegroundColor = ConsoleColor.Gray; if (newToken.ErrorDescription == "Refresh token revoked") { File.WriteAllText("AccessToken.json", ""); if (!isAuthServerOn) { await CreateSpotifyAPI(); } } else { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("Shutting down..."); Console.ForegroundColor = ConsoleColor.Gray; Environment.Exit(0); } } }
private async void spotifyDataLoop() { connected = true; bool playbackState = false; while (true) { if (token.IsExpired()) { token = await auth.RefreshToken(token.RefreshToken); api.AccessToken = token.AccessToken; api.TokenType = token.TokenType; } var playback = api.GetPlayingTrack(); if (playback.HasError()) { Console.WriteLine(playback.Error.Message); } else if (playback.Item == null) { if (currentlyPlaying != "") { currentlyPlaying = ""; OnAudioChange(this, new AudioChangeArgs(playback)); //picture.Image = Properties.Resources.NoSong; //playingLabel.Text = currentlyPlaying; } } else if (currentlyPlaying != playback.Item.Id) { Console.WriteLine(playback.Item.Name + " " + playback.Item.PreviewUrl); currentlyPlaying = playback.Item.Id; OnAudioChange(this, new AudioChangeArgs(playback)); } if (playback.IsPlaying != playbackState) { if (playback.IsPlaying) { ArduinoInterface.sendPlay(playback.ProgressMs, playback.Item.DurationMs); } else { ArduinoInterface.sendPause(playback.ProgressMs, playback.Item.DurationMs); } } playbackState = playback.IsPlaying; Thread.Sleep(1000); } }
private Token RefreshToken(string refreshToken) { AuthorizationCodeAuth auth = new AuthorizationCodeAuth( Settings.ClientId, Settings.ClientSecret, Settings.RedirectUri, Settings.RedirectUri, Scope.None, Settings.StateKey ); return(auth.RefreshToken(refreshToken).Result); }
private static async Task <string> GetAccessToken(ILogger log, string client_id, string client_secret, string redirect_url, string refreshToken) { if (!memoryCache.TryGetValue("AccessToken", out string cacheAccessToken)) { AuthorizationCodeAuth auth = new AuthorizationCodeAuth(client_id, client_secret, redirect_url, redirect_url, Scope.PlaylistReadPrivate | Scope.PlaylistReadCollaborative | Scope.UserModifyPlaybackState | Scope.UserReadPlaybackState); var token = await auth.RefreshToken(refreshToken); cacheAccessToken = token.AccessToken; memoryCache.Set("AccessToken", cacheAccessToken, TimeSpan.FromMinutes(50)); log.LogInformation($"AccessToken updated in cache"); } return(cacheAccessToken); }
private async Task <T> GetAsync <T>(Func <Task <T> > func) where T : BasicModel { T result = await func(); if (result.HasError() && _accessTokenErrorStatusCodes.Contains(result.Error.Status)) { AuthorizationCodeAuth auth = new AuthorizationCodeAuth(_credentials.SpotifyClientId, _credentials.SpotifyClientSecret, _credentials.SpotifyRedirectUri, ""); Token token = await auth.RefreshToken(_credentials.SpotifyRefreshToken); _spotify.AccessToken = token.AccessToken; _spotify.TokenType = token.TokenType; } return(await func()); }
public Token RefreshToken() { this.spotifyToken = this.GetTokenFromFile(); AuthorizationCodeAuth auth = this.CreateAuthorization(); Token refreshedToken = auth.RefreshToken(this.spotifyToken.RefreshToken).Result; refreshedToken.RefreshToken = this.spotifyToken.RefreshToken; this.SpotifyWebApi = this.CreateSpotifyWebApi(this.spotifyToken); this.CreateTokenFile(refreshedToken); this.spotifyToken = refreshedToken; return(refreshedToken); }
async void refreshToken() { try { Token newToken = await auth.RefreshToken(token.RefreshToken); oAuthToken = newToken.AccessToken; txt_accessToken.Invoke((MethodInvoker) delegate { txt_accessToken.Text = oAuthToken; }); } catch (Exception ex) { Console.WriteLine(ex.Message); } }
//saves the playlist to th users account and sends you back to the home page public async Task <ActionResult> Save(string playlistName, bool isPublic = false) { string name = playlistName; if (name == "") { name = ((IndexViewModel)TempData["ViewModel"]).title; } Token token = (Token)TempData["Token"]; AuthorizationCodeAuth auth = (AuthorizationCodeAuth)TempData["Auth"]; SpotifyWebAPI api = (SpotifyWebAPI)TempData["Api"]; Playlist currentPlaylist = (Playlist)TempData["Playlist"]; IndexViewModel viewModel = (IndexViewModel)TempData["ViewModel"]; viewModel.PlaylistURIs = (List <string>)TempData["PlaylistURIs"]; if (token.IsExpired()) { Token newToken = await auth.RefreshToken(token.RefreshToken); api.AccessToken = newToken.AccessToken; api.TokenType = newToken.TokenType; } string userId = api.GetPrivateProfile().Id; FullPlaylist playlist = api.CreatePlaylist(userId, name, isPublic); ErrorResponse response = new ErrorResponse(); response = api.AddPlaylistTracks(playlist.Id, viewModel.PlaylistURIs); TempData["FlashMessage"] = name + " was successfully created and saved to your Spotify account!"; TempData["isError"] = false; //checks for error from laylist save and changes the flass message appropriately. if (response.HasError()) { TempData["FlashMessage"] = "Something went wrong while saving the playlist."; TempData["isError"] = true; } return(RedirectToAction("Index", "Home")); }
private async Task <SpotifyWebAPI> GetSpotifyWebAPI() { if (_token == null) { return(null); } if (DateTimeOffset.UtcNow >= _nextTokenRenewal) { _token = await _authorizationCodeAuth.RefreshToken(_token.RefreshToken); } return(new SpotifyWebAPI { AccessToken = _token.AccessToken, TokenType = _token.TokenType }); }
private async Task RefreshTokenAndConfigure(AuthorizationCodeAuth auth, string refreshToken) { SAPIModels.Token token = await auth.RefreshToken(refreshToken); // Inject RefreshToken back into after each re-auth token.RefreshToken = m_refreshToken; if (token != null && token.Error == null) { m_refreshTokenRoutine = null; Analysis.Log($"Obtained a new authorization token at '{token.CreateDate}'", Analysis.LogLevel.Vital); Configure(token, auth); } else { string errorMsg = token != null ? $"Error - {token.Error}" : "Token is null"; Analysis.LogError($"Unable to refresh authorization token - {errorMsg}", Analysis.LogLevel.Vital); } }
//callback method used if login from "playlist/create" public async Task <ActionResult> CallbackFromCreate(string code) { AuthorizationCodeAuth auth = new AuthorizationCodeAuth( _clientId, _secretId, _redirectURLFromCreate, _serverURI, Scope.PlaylistReadPrivate | Scope.PlaylistReadCollaborative ); Token token = await auth.ExchangeCode(code); SpotifyWebAPI api = new SpotifyWebAPI() { TokenType = token.TokenType, AccessToken = token.AccessToken }; if (token.IsExpired()) { Token newToken = await auth.RefreshToken(token.RefreshToken); api.AccessToken = newToken.AccessToken; api.TokenType = newToken.TokenType; } PrivateProfile profile = await api.GetPrivateProfileAsync(); IndexViewModel viewModel = (IndexViewModel)TempData["ViewModel"]; viewModel.Playlist = (Playlist)TempData["Playlist"]; viewModel.profile = profile; TempData["Api"] = api; TempData["User"] = viewModel.profile; TempData["Token"] = token; TempData["Auth"] = auth; TempData["ViewModel"] = viewModel; TempData["Playlist"] = (Playlist)TempData["Playlist"]; return(RedirectToAction("Create", "Playlist")); }
private async Task GetSpotifyWebAPI() { if (_token == null) { OpenAuthenticationDialog(); return; } if (_token.IsExpired()) { try { if (_api != null) { _api.Dispose(); } _api = null; _token = await _authorizationCodeAuth.RefreshToken(_token.RefreshToken ?? _refreshToken); } catch { // ignored } } if (_api == null) { try { _api = new SpotifyWebAPI { AccessToken = _token.AccessToken, TokenType = _token.TokenType }; } catch (Exception) { _api = null; _authorizationCodeAuth.Stop(); } } }
private async Task RefreshAccessToken() { try { var token = await auth.RefreshToken(refreshToken); if (token.HasError()) { refreshToken = null; System.Diagnostics.Debug.Write("Bad token\r\n"); Authorize(); return; } UpdateAccessToken(token); } catch (Exception e) { initExcpt = e; } }
private static async Task RefreshSpotifyToken() { var token = await s_SpotifyAuth.RefreshToken(s_SpotifyToken.RefreshToken); if (!string.IsNullOrEmpty(token.Error)) { Log.Error(token.Error); Log.Error(token.ErrorDescription); } if (string.IsNullOrEmpty(token.RefreshToken)) { Log.Debug("Token refresh is null"); token.RefreshToken = s_SpotifyToken.RefreshToken; } s_SpotifyAPI.AccessToken = token.AccessToken; s_SpotifyAPI.TokenType = token.TokenType; s_SpotifyToken.CreateDate = DateTime.Now; s_SpotifyToken = token; }
//returns you to the create playlist view public async Task <ActionResult> Create() { if ((Playlist)TempData["Playlist"] == null) { return(RedirectToAction("NoItemSelected", "Error")); } IndexViewModel viewModel = (IndexViewModel)TempData["ViewModel"]; Token userToken = (Token)TempData["Token"]; AuthorizationCodeAuth userAuth = (AuthorizationCodeAuth)TempData["Auth"]; viewModel.profile = (PrivateProfile)TempData["User"]; viewModel.api = (SpotifyWebAPI)TempData["Api"]; viewModel.Playlist = (Playlist)TempData["Playlist"]; viewModel.PlaylistURIs = (List <string>)TempData["PlaylistURIs"]; Console.WriteLine(viewModel.PlaylistURIs); if (viewModel.profile != null) { if (userToken.IsExpired()) { Token newToken = await userAuth.RefreshToken(userToken.RefreshToken); viewModel.api.AccessToken = newToken.AccessToken; viewModel.api.TokenType = newToken.TokenType; } } TempData["PlaylistURIs"] = (List <string>)TempData["PlaylistURIs"]; TempData["Api"] = viewModel.api; TempData["User"] = viewModel.profile; TempData["Token"] = userToken; TempData["Auth"] = userAuth; TempData["ViewModel"] = viewModel; TempData["Playlist"] = viewModel.Playlist; TempData["isFromIndex"] = false; return(View(viewModel)); }
public async Task _refreshtoken(string codeToken) { initialized = false; if (_spotify == null) { _spotify = new SpotifyWebAPI(); } AuthorizationCodeAuth auth = getAuth(); Token token = await auth.RefreshToken(codeToken); _spotify.AccessToken = token.AccessToken; _spotify.TokenType = token.TokenType; if (token.HasError()) { Console.WriteLine(token.Error + " - " + token.ErrorDescription); } else { initialized = true; } }
/// <summary> /// Fetch the current playback status from the Spotify Web API. /// Writes out the playback status to a flat keyvale representations as FieldName=FieldValue\r\n /// so it can be easily parsed /// </summary> /// <param name="opts_">CLI arguments</param> /// <returns>1 for errors, 0 otherwise</returns> static int RunStatus(Status opts_) { SysConsole.WriteLine("Fetching current playback status"); var auth = new AuthorizationCodeAuth(opts_.ClientId, opts_.ClientSecret, string.Empty, string.Empty); var refresh = auth.RefreshToken(opts_.RefreshToken); if (!refresh.Wait(10000)) { SysConsole.WriteLine("Timeout when refreshing token"); return(1); } var token = refresh.Result; var api = new SpotifyWebAPI { AccessToken = token.AccessToken, TokenType = token.TokenType, }; Dump(api.GetPlayback()); return(0); }
public async Task <ActionResult> CreatePlaylist(string inputId, bool isTrack, int range, int numberOfTracks) { IndexViewModel viewModel = new IndexViewModel(); viewModel.profile = (PrivateProfile)TempData["User"]; viewModel.api = (SpotifyWebAPI)TempData["Api"]; Token userToken = (Token)TempData["Token"]; AuthorizationCodeAuth userAuth = (AuthorizationCodeAuth)TempData["Auth"]; if (userToken != null) { if (userToken.IsExpired()) { Token newToken = await userAuth.RefreshToken(userToken.RefreshToken); viewModel.api.AccessToken = newToken.AccessToken; viewModel.api.TokenType = newToken.TokenType; } } viewModel.isTrack = isTrack; Token token = await auth.GetToken(); _spotify = new SpotifyWebAPI() { AccessToken = token.AccessToken, TokenType = token.TokenType }; string artistId = inputId; List <string> trackArtistIds = new List <string>(); SeveralArtists relatedArtists = new SeveralArtists(); List <SeveralArtists> relatedArtistsLists = new List <SeveralArtists>(); //if the search item was a track //get all the artists from that track //then get all the related artists for those artists //then create the playlsit if (isTrack) { viewModel.searchedTrack = _spotify.GetTrack(inputId); artistId = viewModel.searchedTrack.Artists[0].Id; viewModel.title = viewModel.searchedTrack.Name + " Playlist"; viewModel.trackArtists = displayArtistsNames(viewModel.searchedTrack); viewModel.imageUrl = viewModel.searchedTrack.Album.Images[1].Url; relatedArtists.Artists = new List <FullArtist>(); int i = 0; foreach (var artist in viewModel.searchedTrack.Artists) { relatedArtistsLists.Add(_spotify.GetRelatedArtists(artist.Id)); relatedArtistsLists[i].Artists.Insert(0, _spotify.GetArtist(artist.Id)); i++; } viewModel.Playlist = getPlaylistFromTrack(relatedArtistsLists, numberOfTracks, range, viewModel.searchedTrack.Id); viewModel.trackLengths = (Dictionary <string, string>)TempData["TrackLengths"]; } //if the search item was an artist, get the related artists, and create a playlist else { viewModel.searchedArtist = _spotify.GetArtist(artistId); viewModel.title = viewModel.searchedArtist.Name + " Playlist"; viewModel.imageUrl = viewModel.searchedArtist.Images[1].Url; relatedArtists = _spotify.GetRelatedArtists(artistId); relatedArtists.Artists.Insert(0, (_spotify.GetArtist(artistId))); viewModel.Playlist = getPlaylistFromArtist(relatedArtists, numberOfTracks, range); viewModel.trackLengths = (Dictionary <string, string>)TempData["TrackLengths"]; } TempData["PlaylistURIs"] = (List <string>)TempData["PlaylistURIs"]; TempData["Playlist"] = viewModel.Playlist; TempData["Token"] = userToken; TempData["Auth"] = userAuth; TempData["ViewModel"] = viewModel; return(RedirectToAction("Create")); }
public async Task <ActionResult> Index(IndexViewModel viewModel) { TempData["Playlist"] = null; viewModel.isFromIndex = true; viewModel.profile = (PrivateProfile)TempData["User"]; viewModel.api = (SpotifyWebAPI)TempData["Api"]; Token token = (Token)TempData["Token"]; AuthorizationCodeAuth auth = (AuthorizationCodeAuth)TempData["Auth"]; if (token != null) { if (token.IsExpired()) { Token newToken = await auth.RefreshToken(token.RefreshToken); viewModel.api.AccessToken = newToken.AccessToken; viewModel.api.TokenType = newToken.TokenType; } CursorPaging <PlayHistory> histories = viewModel.api.GetUsersRecentlyPlayedTracks(20); Paging <FullArtist> artists = viewModel.api.GetUsersTopArtists(TimeRangeType.ShortTerm, 20); //creates a random list from 0 to the number of recent tracks and 0 to recent artists //then shuffled to be used to display random recent artists and tracks //did the same thing for both for the case that there are not 20 recent artists or tracks to get //the lists might then be different sizes and could throw an index out of bounds error Random rand = new Random(); List <int> randArtistNumbs = new List <int>(); List <int> randTrackNumbs = new List <int>(); for (int i = 0; i < artists.Items.Count; i++) { randArtistNumbs.Add(i); } for (int i = 0; i < histories.Items.Count; i++) { randTrackNumbs.Add(i); } //shuffles the list of artist numbers int n = randArtistNumbs.Count; while (n > 1) { n--; int k = rand.Next(n + 1); int temp = randTrackNumbs[k]; randTrackNumbs[k] = randTrackNumbs[n]; randTrackNumbs[n] = temp; } //shuffle list of track numbers int m = randTrackNumbs.Count; while (m > 1) { m--; int k = rand.Next(m + 1); int temp = randTrackNumbs[k]; randTrackNumbs[k] = randTrackNumbs[m]; randTrackNumbs[m] = temp; } //adds up to 5 recent artists to the top artists view property for (int i = 0; i < 5; i++) { if (artists.Items[randArtistNumbs[i]] != null) { viewModel.topArtists.Add(artists.Items[randArtistNumbs[i]]); } } //adds non duplicate tracks to the recent tracks property viewModel.recentTracks = new Playlist(); int count = 0; while (viewModel.recentTracks.TrackList.Count < 5 && count < randTrackNumbs.Count) { string trackId = histories.Items[randTrackNumbs[count]].Track.Id; if (!viewModel.recentTracks.hasTrack(trackId)) { viewModel.recentTracks.TrackList.Add(viewModel.api.GetTrack(trackId)); } count++; } } ViewBag.FlashMessage = (string)TempData["FlashMessage"]; if (TempData["isError"] != null) { ViewBag.isError = (bool)TempData["isError"]; } TempData["User"] = viewModel.profile; TempData["Api"] = viewModel.api; TempData["Token"] = token; TempData["Auth"] = auth; TempData["isFromIndex"] = true; TempData["ViewModel"] = viewModel; return(View(viewModel)); }