public async Task <AlbumsResponse> Get([FromUri] AlbumsRequest request)
{
AddNewRelicCustomParameters(request);
var albumsResponse = new AlbumsResponse {
Albums = new List <Album>(),
Pages = new List <Page>(),
Info = new AlbumsResponseInfo {
Genre = request.Genre, Page = request.Page, Source = request.Source
}
};
try {
ValidateRequest(request);
var albums = await _albumService.GetAlbumsByGenreAsync(request.Source, request.Genre, request.Page);
albumsResponse.Albums = albums.Items;
albumsResponse.Pages = albums.Pages;
albumsResponse.Info.Count = albums.Items.Count;
albumsResponse.ResponseStatusCode = HttpStatusCode.OK;
return(albumsResponse);
}
catch (ServiceApiException saex) {
LogError(saex);
albumsResponse.ResponseStatusCode = saex.StatusCode;
return(albumsResponse);
}
catch (Exception ex) {
LogError(ex);
albumsResponse.ResponseStatusCode = HttpStatusCode.InternalServerError;
return(albumsResponse);
}
}
public async Task <IActionResult> Albums(AlbumsRequest request)
{
try
{
if (request == null)
{
this._logger.LogWarning("BadRequest in GetAlbums", new object[] { request, System.Diagnostics.Activity.Current?.RootId });
return(BadRequest(ModelState));
}
var albumsResult = await this._typicodeService.GetAlbums(request);
if (!albumsResult.Success)
{
return(StatusCode(500, albumsResult.Message));
}
return(Ok(albumsResult.Value));
}
catch (Exception ex)
{
this._logger.LogError(ex, "Exception in GetAlbums", new object[] { request, System.Diagnostics.Activity.Current?.RootId });
return(StatusCode(500, "Server Error"));
}
}
public List <FullAlbum> GetFullAlbums(List <string> ids)
{
var fullAlbums = new List <FullAlbum>();
for (int i = 0; i < ids.Count; i += (ids.Count - i) >= 20 ? 20 : (ids.Count - i))
{
var request = new AlbumsRequest(ids.GetRange(i, (ids.Count - i) < 20 ? (ids.Count - i) : 20));
var response = client.Albums.GetSeveral(request).Result;
fullAlbums.AddRange(response.Albums);
}
return(fullAlbums);
}
public void GetAllSuccess()
{
Setup();
AlbumsRequest request = new AlbumsRequest();
albumAppServiceMock.Setup(p => p.GetAllAlbumsByFilter(It.IsAny <GetAllAlbumsByFilterRequest>())).Returns(getAllAlbumsByFilterResponse);
var result = controller.Get(request);
Assert.AreEqual(result.ListAlbums.Count, 2);
}
private void ValidateRequest(AlbumsRequest request)
{
if (string.IsNullOrWhiteSpace(request.Genre))
{
throw new ServiceApiException(HttpStatusCode.BadRequest,
string.Format(ServiceApiException.InvalidValueErrorMessageFormat, "Genre", request.Genre));
}
if (request.Page <= 0)
{
throw new ServiceApiException(HttpStatusCode.BadRequest,
string.Format(ServiceApiException.InvalidValueErrorMessageFormat, "Page", request.Page));
}
}
public AlbumsGetResponse Get([FromQuery] AlbumsRequest request)
{
AlbumsGetResponse albumResponse = new AlbumsGetResponse();
albumResponse.ListAlbums = new List <Album>();
GetAllAlbumsByFilterRequest getAllAlbumsByFilterRequest = _mapper.Map <GetAllAlbumsByFilterRequest>(request);
var appServiceResponse = _albumsAppService.GetAllAlbumsByFilter(getAllAlbumsByFilterRequest);
albumResponse = _mapper.Map <AlbumsGetResponse>(appServiceResponse);
return(albumResponse);
}
public async Task <ResultHandler <IEnumerable <Album> > > GetAlbums(AlbumsRequest request)
{
try
{
if (request == null)
{
return(ResultHandler.Fail <IEnumerable <Album> >(E_ErrorType.EntityNotValid));
}
Dictionary <string, string> nameValueCollection = new Dictionary <string, string>();
if (request.Id.HasValue)
{
nameValueCollection.Add("Id", request.Id.Value.ToString());
}
HttpRequestModel httpRequestModel = new HttpRequestModel()
{
MethodName = "Albums",
CancellationToken = new System.Threading.CancellationToken(),
ClientName = E_HttpClient.Typicode,
CompletionOption = System.Net.Http.HttpCompletionOption.ResponseContentRead,
Headers = null,
HttpContent = null,
HttpMethod = System.Net.Http.HttpMethod.Get,
QueryString = null
};
List <Album> result = new List <Album>();
for (int i = 0; i < 50; i++)
{
var albumsResponseResult = await this._httpClientFactoryService.GetHttpResponse <Album[]>(httpRequestModel);
if (!albumsResponseResult.Success)
{
return(ResultHandler.Fail <IEnumerable <Album> >(albumsResponseResult.ErrorType));
}
result.AddRange(albumsResponseResult.Value);
}
return(ResultHandler.Ok <IEnumerable <Album> >(result));
}
catch (System.Exception ex)
{
return(ResultHandler.Fail <IEnumerable <Album> >(ex));
}
}
public async Task Test_ListAlbums_Favourite()
{
// Arrange
_client.Favourites.AlbumIds = new List <string> {
"2C5HYffMBumERQlNfceyrO"
};
// Act
var request = new AlbumsRequest()
{
AlbumType = AlbumType.Favourite
};
var response = await _client.ListAlbumsAsync(request);
// Assert
Assert.IsNotNull(response);
}
public async Task Test_ListAlbums_NewReleases()
{
var request = new AlbumsRequest()
{
AlbumType = AlbumType.NewReleases
};
var items = await _client.ListAlbumsAsync(request);
Assert.IsNotNull(items?.Items);
Assert.IsTrue(items?.Items.Count > 0);
var more = await _client.ListAlbumsAsync(items);
Assert.IsNotNull(more?.Items);
Assert.IsTrue(more?.Items.Count > 0);
}
public async Task Test_ListAlbums_Multiple()
{
var request = new AlbumsRequest()
{
AlbumType = AlbumType.Multiple,
MultipleAlbumIds = new List <string>
{
"5sXSHscDjBez8VF20cSyad",
"31qVWUdRrlb8thMvts0yYL"
}
};
var items = await _client.ListAlbumsAsync(request);
Assert.IsNotNull(items?.Items);
Assert.IsTrue(items?.Items.Count > 0);
}
public async Task Test_ListAlbums_Search()
{
var request = new AlbumsRequest()
{
AlbumType = AlbumType.Search,
Value = "Tubular Bells"
};
var items = await _client.ListAlbumsAsync(request);
Assert.IsNotNull(items?.Items);
Assert.IsTrue(items?.Items.Count > 0);
var more = await _client.ListAlbumsAsync(items);
Assert.IsNotNull(more?.Items);
Assert.IsTrue(more?.Items.Count > 0);
}
public async Task Test_ListAlbums_Artist()
{
var request = new AlbumsRequest()
{
AlbumType = AlbumType.Artist,
Value = "43ZHCT0cAZBISjO8DG9PnE",
IncludeGroup = new IncludeGroupRequest()
{
Album = true
}
};
var items = await _client.ListAlbumsAsync(request);
Assert.IsNotNull(items?.Items);
Assert.IsTrue(items?.Items.Count > 0);
var more = await _client.ListAlbumsAsync(items);
Assert.IsNotNull(more?.Items);
Assert.IsTrue(more?.Items.Count > 0);
}
public void GetAllSuccess_pageSize()
{
Setup();
AlbumsRequest request = new AlbumsRequest();
request.PageSize = 1;
getAllAlbumsByFilterResponse.ListAlbums = getAllAlbumsByFilterResponse.ListAlbums
.Skip((request.PageNumber - 1) * request.PageSize)
.Take(request.PageSize)
.ToList();
albumAppServiceMock.Setup(p => p.GetAllAlbumsByFilter(It.IsAny <GetAllAlbumsByFilterRequest>())).Returns(getAllAlbumsByFilterResponse);
var result = controller.Get(request);
Assert.AreEqual(result.ListAlbums.Count, 1);
Assert.AreEqual(result.ListAlbums[0].Id, 1);
}
private void AddNewRelicCustomParameters(AlbumsRequest request)
{
_newRelicTransactionManager.AddCustomParameter("request.Source", request.Source);
_newRelicTransactionManager.AddCustomParameter("request.Genre", request.Genre);
_newRelicTransactionManager.AddCustomParameter("request.Page", request.Page);
}
public Task <List <string> > FindAllConnectedArtists(string artistID, float priority)
{
return(Task.Run(() =>
{
CheckedArtists.Add(artistID);
List <string> artistNames = new List <string>();
HashSet <string> connectedArtists = new HashSet <string>();
Paging <SimpleAlbum> pagingAlbums;
try
{
Task <Paging <SimpleAlbum> > pagingAlbumsTask = Spotify.Artists.GetAlbums(artistID);
pagingAlbumsTask.Wait();
pagingAlbums = pagingAlbumsTask.Result;
} catch {
Thread.Sleep(3500);
Task <Paging <SimpleAlbum> > pagingAlbumsTask = Spotify.Artists.GetAlbums(artistID);
pagingAlbumsTask.Wait();
pagingAlbums = pagingAlbumsTask.Result;
}
List <string> albumIDs = new List <string>();
foreach (SimpleAlbum simpleAlbum in pagingAlbums.Items)
{
albumIDs.Add(simpleAlbum.Id);
}
if (albumIDs.Count > 0)
{
AlbumsRequest request = new AlbumsRequest(albumIDs);
AlbumsResponse albumsResponse;
try
{
Task <AlbumsResponse> fullAlbumTask = Spotify.Albums.GetSeveral(request);
fullAlbumTask.Wait();
albumsResponse = fullAlbumTask.Result;
}
catch
{
Thread.Sleep(3500);
Task <AlbumsResponse> fullAlbumTask = Spotify.Albums.GetSeveral(request);
fullAlbumTask.Wait();
albumsResponse = fullAlbumTask.Result;
}
foreach (FullAlbum fullAlbum in albumsResponse.Albums)
{
Paging <SimpleTrack> simpleTracks = fullAlbum.Tracks;
foreach (SimpleTrack simpleTrack in simpleTracks.Items)
{
List <SimpleArtist> simpleArtistsList = simpleTrack.Artists;
List <String> simpleArtistsOnTrack = new List <string>();
foreach (SimpleArtist simpleArtist in simpleArtistsList)
{
simpleArtistsOnTrack.Add(simpleArtist.Id);
}
if (simpleArtistsOnTrack.Contains(artistID))
{
foreach (SimpleArtist simpleArtist in simpleTrack.Artists)
{
if (!ArtistIdToName.ContainsKey(simpleArtist.Id))
{
ArtistIdToName.Add(simpleArtist.Id, simpleArtist.Name);
}
if (!ArtistsToCheck.Contains(simpleArtist.Id) && !CheckedArtists.Contains(simpleArtist.Id))
{
ArtistsToCheck.Enqueue(simpleArtist.Id, priority + 1);
Edge edge = new Edge(artistID, simpleTrack.Name, simpleArtist.Id);
if (!containsEdge(edge))
{
ArtistsGraph.AddEdge(artistID, simpleTrack.Name, simpleArtist.Id);
//Edges.Add(edge);
}
}
}
}
}
}
}
return connectedArtists.ToList();
}));
}