/// <inheritdoc />
public async Task <IList <FullAlbum> > GetAlbums(IList <SpotifyUri> albumUris, string market)
{
// Because we support more then 50 albums uris as input.
// but the spotify api only supports a maximum of 50,
// lets fix that by creating multiple lists of 50.
var lists = albumUris.ChunkBy(50);
var res = new List <FullAlbum>();
foreach (var l in lists)
{
var s = string.Join(",", l.Select(x => x.Id).ToArray());
var r = await ApiClient.GetAsync <MultipleAlbums>(
MakeUri(
$"albums",
("ids", s),
("market", market)),
this.Token);
if (r.Response is MultipleAlbums albums)
{
res.AddRange(albums.Albums);
}
}
return(res);
}
/// <inheritdoc />
public async Task <IList <FullTrack> > GetArtistsTopTracks(SpotifyUri artistUri, string market)
{
var r = await ApiClient.GetAsync <List <FullTrack> >(
MakeUri(
$"artists/{artistUri.Id}/top-tracks",
("market", market)),
this.Token);
if (r.Response is List <FullTrack> res)
{
return(res);
}
return(new List <FullTrack>());
}
/// <inheritdoc />
public async Task <FullAlbum> GetAlbum(SpotifyUri albumUri, string market)
{
var r = await ApiClient.GetAsync <FullAlbum>(
MakeUri(
$"albums/{albumUri.Id}",
("market", market)),
this.Token);
if (r.Response is FullAlbum album)
{
return(album);
}
return(new FullAlbum());
}
/// <inheritdoc />
public async Task <FullTrack> GetTrack(SpotifyUri uri, string market)
{
var r = await ApiClient.GetAsync <FullTrack>(
MakeUri(
$"tracks/{uri.Id}",
("market", market)),
this.Token);
if (r.Response is FullTrack res)
{
return(res);
}
return(new FullTrack());
}
/// <inheritdoc />
public async Task <FullPlaylist> GetPlaylist(SpotifyUri playlistUri, string market)
{
var r = await ApiClient.GetAsync <FullPlaylist>(
MakeUri(
$"users/{playlistUri.UserId}/playlists/{playlistUri.Id}",
("market", market)),
this.Token);
if (r.Response is FullPlaylist res)
{
return(res);
}
return(new FullPlaylist());
}
/// <inheritdoc />
public async Task <CurrentlyPlaying> GetCurrentlyPlaying(string market = "")
{
var r = await ApiClient.GetAsync <CurrentlyPlaying>(
MakeUri(
$"me/player/currently-playing",
("market", market)),
this.Token);
if (r.Response is CurrentlyPlaying res)
{
return(res);
}
return(new CurrentlyPlaying());
}
/// <inheritdoc />
public async Task <SearchResult> Search(
string query,
SearchType searchTypes,
string market,
int offset,
int resultLimit)
{
var searchTypeString = string.Empty;
if (searchTypes.HasFlag(SearchType.Album))
{
searchTypeString += "album,";
}
if (searchTypes.HasFlag(SearchType.Artist))
{
searchTypeString += "artist,";
}
if (searchTypes.HasFlag(SearchType.Playlist))
{
searchTypeString += "playlist,";
}
if (searchTypes.HasFlag(SearchType.Track))
{
searchTypeString += "track,";
}
var r = await ApiClient.GetAsync <ApiSearchResult>(
MakeUri(
"search",
("q", query.Replace(' ', '+')),
("type", searchTypeString.Remove(searchTypeString.Length - 1)),
("offset", offset.ToString()),
("market", market)),
this.Token);
if (r.Response is ApiSearchResult res)
{
var result = new SearchResult
{
Albums = res.Albums.Items,
Playlists = res.Playlists.Items,
Tracks = res.Tracks.Items,
Artists = res.Artists.Items
};
return(result);
}
return(new SearchResult());
}
/// <inheritdoc />
public async Task <IList <PlaylistTrack> > GetPlaylistTracks(
SpotifyUri playlistUri, int maxResults, int offset, string market)
{
var r = await ApiClient.GetAsync <Paging <PlaylistTrack> >(
MakeUri(
$"users/{playlistUri.UserId}/playlists/{playlistUri.Id}/tracks?limit=100&offset={offset}",
("market", market)),
this.Token);
if (r.Response is Paging <PlaylistTrack> res)
{
return(await res.LoadToList(this.Token, maxResults));
}
return(new List <PlaylistTrack>());
}
/// <inheritdoc />
public async Task <IList <SimpleTrack> > GetAlbumTracks(SpotifyUri albumUri, string market)
{
var r = await ApiClient.GetAsync <Paging <SimpleTrack> >(
MakeUri(
$"albums/{albumUri.Id}/tracks",
("limit", "50"),
("offset", "0"), // TODO: Offset
("market", market)),
this.Token);
if (r.Response is Paging <SimpleTrack> tracks)
{
return(await tracks.LoadToList(this.Token));
}
return(new List <SimpleTrack>());
}
/// <inheritdoc />
public async Task <IList <FullTrack> > GetTracks(IList <SpotifyUri> uris, string market)
{
Validation.ValidateList(uris, 1, 50);
var r = await ApiClient.GetAsync <List <FullTrack> >(
MakeUri(
$"tracks",
("ids", string.Join(",", uris.Select(x => x.Id))),
("market", market)),
this.Token);
if (r.Response is List <FullTrack> res)
{
return(res);
}
return(new List <FullTrack>());
}
/// <inheritdoc />
public async Task <(string Message, IList <SimplePlaylist> Playlists)> GetFeaturedPlaylists(
string locale,
string country,
DateTime?timeStamp,
int maxResults,
int offset)
{
var r = await ApiClient.GetAsync <FeaturedPlaylistResponse>(
MakeUri(
$"browse/featured-playlists",
("locale", locale),
("country", country),
("timestamp", $"{timeStamp:O}")),
this.Token);
if (r.Response is FeaturedPlaylistResponse res)
{
return(res.Message, res.Playlists);
}
return(string.Empty, new List <SimplePlaylist>());
}
/// <inheritdoc />
public async Task <IList <SimpleAlbum> > GetArtistAlbums(SpotifyUri artistUri, AlbumType albumTypes, string market, int maxResults, int offset)
{
var albumTypeString = string.Empty;
if (albumTypes.HasFlag(AlbumType.Album))
{
albumTypeString += "album,";
}
if (albumTypes.HasFlag(AlbumType.AppearsOn))
{
albumTypeString += "appears_on,";
}
if (albumTypes.HasFlag(AlbumType.Compilation))
{
albumTypeString += "compilation,";
}
if (albumTypes.HasFlag(AlbumType.Single))
{
albumTypeString += "compilation,";
}
albumTypeString = albumTypeString.Remove(albumTypeString.Length - 1);
var r = await ApiClient.GetAsync <Paging <SimpleAlbum> >(
MakeUri(
$"artists/{artistUri.Id}/albums?{albumTypeString}",
("album_type", albumTypeString),
("limit", "50"),
("offset", offset.ToString()),
("market", market)),
this.Token);
if (r.Response is Paging <SimpleAlbum> res)
{
return(await res.LoadToList(this.Token));
}
return(new List <SimpleAlbum>());
}
public void MakeUriTests(string expected, string r, string q, string v)
{
var uri = MakeUri(r, (queryParameter: q, value: v));
Assert.Equal(expected, uri.AbsoluteUri);
}
