public List <SpotibroModels.Track> Convert(TopTracks topTracks)
{
return(topTracks.Tracks.Select(p => new SpotibroModels.Track
{
Name = p.Name,
Album = Convert(p.Album),
Artists = Convert(p.Artists),
Duration = p.Duration,
Id = p.Id,
IsExplicit = p.Explicit,
}).ToList());
}
/// <summary>
/// Returns list of top tracks for the specified artist-/spotify id in the given country
/// </summary>
/// <param name="spotifyId">id of the artist</param>
/// <param name="countryCode">top tracks from this country</param>
/// <returns></returns>
public async Task <TopTracks> TopTracksAsync(string spotifyId, string countryCode)
{
string token = await GetAuthenticationTokenAsync().ConfigureAwait(false);
RestRequest request = RequestBuilder.CreateTopTracksRequest(spotifyId, countryCode, token);
IRestResponse response = await ExecuteRequestAsync(request).ConfigureAwait(false);
TopTracks topTracks = DeserializeResponse(response.Content, new TopTracks());
return(topTracks);
}
public static IEnumerable <Track> PrintMyTopTracks(this TopTracks result, int trackCount = 10)
{
Console.WriteLine();
_logger.Info($"Printing a list of my {trackCount} most 'scrobbled' tracks");
Console.WriteLine("------------------------------------------------");
foreach (var track in result.Tracks.Take(trackCount))
{
_logger.Info($"{track.Rank}:\t'{track.Name}' by {track.Artist.Name}.");
}
Console.WriteLine("------------------------------------------------");
return(result.Tracks.Skip(trackCount));
}
public static List <TopTrackViewModel> ToViewModel(this TopTracks topTracks)
{
List <TopTrackViewModel> mappedModel = null;
try
{
mappedModel = ModelMapper.Mapper.Map <List <TopTrackViewModel> >(topTracks);
}
catch (Exception e)
{
SpotifyLogger.WriteExceptionToLog("TopTracksExtension", "ToViewModel", e);
return(null);
}
return(mappedModel);
}
public List <TopTrackViewModel> Convert(TopTracks source, List <TopTrackViewModel> destination, ResolutionContext context)
{
List <TopTrackViewModel> ttvm = new List <TopTrackViewModel>();
List <string> albumIds = source.Tracks.Select(x => x.Album.Id).Distinct().ToList();
try
{
foreach (string id in albumIds)
{
var album = source.Tracks.FirstOrDefault(a => a.Album.Id == id)?.Album;
if (album == null)
{
continue;
}
var albumTrackList = source.Tracks.Where(v => v.Album.Id == id).ToList();
ttvm.Add(new TopTrackViewModel()
{
AlbumId = album.Id,
AlbumName = album.Name,
SpotifyUrl = album.ExternalUrls.Spotify,
AlbumImageSource = album.Images != null && album.Images.Any() ? album.Images.First().Url : string.Empty,
ArtistName = album.Artists != null && album.Artists.Any() ? string.Join(", ", album.Artists.Select(n => n.Name).Distinct()) : string.Empty,
TrackList = albumTrackList.Select(c => new TrackViewModel()
{
TrackId = c.Id,
TrackName = c.Name,
TrackNumber = c.TrackNumber,
Duration = Math.Round((decimal)c.Duration_ms / 1000 / 60, 2)
}).OrderBy(i => i.TrackNumber).ToList()
});
}
}
catch (Exception e)
{
SpotifyLogger.WriteExceptionToLog(this.GetType().Name, new StackTrace().GetFrame(0).GetMethod().Name, e);
throw;
}
return(ttvm);
}
protected override void InitializeCommands()
{
base.InitializeCommands();
PlayTrackCommand = new DelegateCommand <IAudio>(track =>
{
AudioService.Instance.PlayAudio(track, TopTracks.OfType <IAudio>().ToList());
});
GoToArtistCommand = new DelegateCommand <DiscoveryArtist>(artist =>
{
NavigationService.Navigate(typeof(ArtistView), new Dictionary <string, object>
{
["artist"] = artist
});
Analytics.TrackEvent(AnalyticsEvent.SearchGoToRelatedArtist, new Dictionary <string, object>
{
["artistId"] = artist.Id,
["artistName"] = artist.Name
});
});
GoToAlbumCommand = new DelegateCommand <DiscoveryAlbum>(album =>
{
NavigationService.Navigate(typeof(AlbumView), new Dictionary <string, object>
{
["album"] = album
});
Analytics.TrackEvent(AnalyticsEvent.SearchGoToArtistAlbum, new Dictionary <string, object>
{
["albumId"] = album.Id,
["albumName"] = album.Title
});
});
ShowMoreTracksCommand = new DelegateCommand(() =>
{
NavigationService.Navigate(typeof(TracklistView), new Dictionary <string, object>
{
["tracks"] = _allTopTracks
});
});
ShowMoreArtistsCommand = new DelegateCommand(() =>
{
NavigationService.Navigate(typeof(ArtistlistView), new Dictionary <string, object>
{
["artists"] = RelatedArtists
});
});
ShowMoreAlbumsCommand = new DelegateCommand(() =>
{
NavigationService.Navigate(typeof(AlbumListView), new Dictionary <string, object>
{
["albums"] = Albums
});
});
}
public SpotibroModels.ArtistInformation Convert(SpotifyModels.ArtistInformation artist, TopTracks topTracks)
{
return(new SpotibroModels.ArtistInformation
{
Artist = ConvertArtist(artist),
TopTracks = Convert(topTracks)
});
}
