public Task <WebResults> SearchAsync(string query, WebResults.Type searchType = WebResults.Type.Song,
int limit = 10, string pageToken = null)
{
return(Task.FromResult(new WebResults
{
Albums = CreateDummyAlbums(),
Artists = CreateDummyArtists(),
Songs = CreateDummySongs()
}));
}
public override async Task <WebResults> SearchAsync(string query,
WebResults.Type searchType = WebResults.Type.Song,
int limit = 20, string pageToken = null)
{
switch (searchType)
{
default:
var songResponse = await
(pageToken == null
? _client.SearchAsync(Namespace.music, query, ContentSource.Catalog, SearchFilter.Tracks,
maxItems: limit)
: _client.SearchContinuationAsync(Namespace.music, pageToken));
var songResults = new WebResults
{
HasMore = songResponse.Tracks?.ContinuationToken != null,
PageToken = songResponse.Tracks?.ContinuationToken,
Songs = songResponse.Tracks?.Items?.Select(CreateSong).ToList()
};
return(songResults);
case WebResults.Type.Artist:
var artistResponse =
await
(pageToken == null
? _client.SearchAsync(Namespace.music, query, ContentSource.Catalog,
SearchFilter.Artists, maxItems: limit)
: _client.SearchContinuationAsync(Namespace.music, pageToken));
var artistResults = new WebResults
{
HasMore = artistResponse.Artists?.ContinuationToken != null,
PageToken = artistResponse.Artists?.ContinuationToken,
Artists = artistResponse.Artists?.Items?.Select(CreateArtist).ToList()
};
return(artistResults);
case WebResults.Type.Album:
var albumResponse =
await
(pageToken == null
? _client.SearchAsync(Namespace.music, query, ContentSource.Catalog, SearchFilter.Albums,
maxItems: limit)
: _client.SearchContinuationAsync(Namespace.music, pageToken));
var albumResults = new WebResults
{
HasMore = albumResponse.Albums?.ContinuationToken != null,
PageToken = albumResponse.Albums?.ContinuationToken,
Albums =
albumResponse.Albums?.Items?.Select(CreateAlbum).Distinct(new WebAlbum.Comparer()).ToList()
};
return(albumResults);
}
}
public override async Task <WebResults> SearchAsync(string query,
WebResults.Type searchType = WebResults.Type.Song, int limit = 20, string pageToken = null)
{
int offset;
int.TryParse(pageToken, out offset);
using (var response =
await new SpotifySearchRequest(query)
.Type(searchType)
.Limit(limit)
.Offset(offset)
.ToResponseAsync()
.DontMarshall())
{
if (!response.HasData)
{
return(null);
}
if (response.Data.HasError())
{
throw new ProviderException(response.Data.ErrorResponse.Message);
}
WebResults results;
switch (searchType)
{
case WebResults.Type.Song:
results = CreateResults(response.Data.Tracks);
results.Songs = response.Data.Tracks?.Items?.Select(CreateSong).Distinct(new WebSong.Comparer()).ToList();
break;
case WebResults.Type.Artist:
results = CreateResults(response.Data.Artists);
results.Artists = response.Data.Artists?.Items?.Select(CreateArtist).ToList();
break;
default:
results = CreateResults(response.Data.Albums);
results.Albums =
response.Data.Albums?.Items?.Select(CreateAlbum).Distinct(new WebAlbum.Comparer()).ToList();
break;
}
return(results);
}
}
public override async Task <WebResults> SearchAsync(string query,
WebResults.Type searchType = WebResults.Type.Song,
int limit = 20, string pageToken = null)
{
using (var client = CreateClient())
{
var page = string.IsNullOrEmpty(pageToken) ? 1 : int.Parse(pageToken);
WebResults results;
switch (searchType)
{
case WebResults.Type.Song:
{
var response = await client.Track.SearchAsync(query, page, limit);
results = CreateResults(response);
results.Songs = response.Content.Select(CreateSong).ToList();
}
break;
case WebResults.Type.Artist:
{
var response = await client.Artist.SearchAsync(query, page, limit);
results = CreateResults(response);
results.Artists = response.Content.Select(CreateArtist).ToList();
}
break;
default:
{
var response = await client.Album.SearchAsync(query, page, limit);
results = CreateResults(response);
results.Albums = response.Content.Select(CreateAlbum).ToList();
}
break;
}
return(results);
}
}
public override async Task <WebResults> SearchAsync(string query,
WebResults.Type searchType = WebResults.Type.Song,
int limit = 20, string pageToken = null)
{
int offset;
int.TryParse(pageToken, out offset);
using (
var response =
await new DeezerSearchRequest <JToken>(query)
.Type(searchType)
.Limit(limit)
.Offset(offset)
.ToResponseAsync()
.DontMarshall())
{
if (!response.HasData)
{
return(null);
}
var results = CreateResults(response.Data, limit, offset);
switch (searchType)
{
case WebResults.Type.Song:
results.Songs = response.Data.Data?.Select(CreateSong).ToList();
break;
case WebResults.Type.Artist:
results.Artists = response.Data.Data?.Select(CreateArtist).ToList();
break;
default:
results.Albums = response.Data.Data?.Select(CreateAlbum).Distinct(new WebAlbum.Comparer()).ToList();
break;
}
return(results);
}
}
public DeezerChartRequest(WebResults.Type type)
{
this.Url("http://api.deezer.com/chart/0/{type}").Type(type);
}
public DeezerChartRequest <T> Type(WebResults.Type type)
{
return(this.UrlParam("type", type.ToString().ToLower().Replace("song", "track") + "s"));
}
public SpotifySearchRequest Type(WebResults.Type type)
{
return(this.Param("type", type.ToString().ToLower().Replace("song", "track")));
}
public abstract Task <WebResults> SearchAsync(string query, WebResults.Type searchType = WebResults.Type.Song,
int limit = 20, string pageToken = null);
