public async Task <IActionResult> Add(CreateGenreViewModel model)
{
if (ModelState.IsValid)
{
GenreDetail existingGenre = await _genreRepo.GetAsync(model.Name);
if (existingGenre == null)
{
try
{
await _genreRepo.AddAsync(model.Name);
this.SetBootstrapPageAlert("Success", "New genre added", BootstrapAlertType.success);
return(RedirectToAction(nameof(Index)));
}catch (Exception e)
{
_logger.LogError(e, "Error creating genre");
ModelState.AddModelError(nameof(model.Name), "Error adding genre to the database");
return(View(model));
}
}
else
{
ModelState.AddModelError(nameof(model.Name), "A genre with this name already exists");
return(View(model));
}
}
else
{
return(View(model));
}
}
public async Task <GenreDetail> GetAsync(string genre, PublishStatus?contentPublicationFlags = null)
{
PublishedStatusEnumMapper statusMapper = new PublishedStatusEnumMapper();
DbPublishedStatus contentStatusFlags = statusMapper.GetAllDbFlags();
if (contentPublicationFlags.HasValue)
{
contentStatusFlags = statusMapper.Map(contentPublicationFlags.Value);
}
var dbGenre = await _context.Genres.SingleOrDefaultAsync(x => x.Name == genre);
if (dbGenre != null)
{
var numAlbums = await _context.Genres.Where(g => g.Name == genre).SelectMany(x => x.AlbumGenres).CountAsync(x => x.Album.PublishStatus == DbPublishedStatus.PUBLISHED);
var numArtists = await _context.Genres.Where(g => g.Name == genre).SelectMany(x => x.ArtistGenres).CountAsync(x => x.Artist.PublishStatus == DbPublishedStatus.PUBLISHED);
GenreDetail result = new GenreDetail()
{
Name = dbGenre.Name,
TotalAlbums = numAlbums,
TotalArtists = numArtists,
Created = new DateTime(dbGenre.CreatedUtc.Ticks, DateTimeKind.Utc)
};
return(result);
}
else
{
return(null);
}
}
public async Task <IActionResult> Put([FromRoute] string genre = null)
{
if (!string.IsNullOrWhiteSpace(genre))
{
try{
GenreDetail existingGenre = await _repo.GetAsync(genre, contentPublicationFlags : PublishStatus.PUBLISHED);
if (existingGenre != null)
{
return(Ok(existingGenre));
}
else
{
GenreDetail result = await _repo.AddAsync(genre);
return(this.CreatedAtRoute(new { controller = "genre", action = nameof(Get), genre = genre }, result));
}
}catch (RepositoryException e) {
return(BadRequest(new ApiErrorRep(e.Message)));
}catch (Exception e) {
_logger.LogError("AddArtist", e, "Error adding artist");
return(StatusCode(500, new ApiErrorRep("Unknown error")));
}
}
else
{
return(BadRequest(new ApiErrorRep("No genre provided")));
}
}
public async Task <IActionResult> Get([FromRoute] string genre = null)
{
if (!string.IsNullOrWhiteSpace(genre))
{
try{
GenreDetail genreResult = await _repo.GetAsync(genre, contentPublicationFlags : PublishStatus.PUBLISHED);
if (genreResult != null)
{
return(Ok(genreResult));
}
else
{
return(NotFound(new ApiErrorRep($"Genre not found")));
}
}catch (RepositoryException e) {
return(BadRequest(new ApiErrorRep(e.Message)));
}catch (Exception e) {
_logger.LogError("AddArtist", e, "Error adding artist");
return(StatusCode(500, new ApiErrorRep("Unknown error")));
}
}
else
{
return(BadRequest(new ApiErrorRep("No genre provided")));
}
}
public SelectableGenreViewModel Map(GenreDetail sourceObject)
{
return(new SelectableGenreViewModel
{
Name = sourceObject.Name,
IsSelected = false
});
}
public async Task <ActionResult> Remove(string name)
{
GenreViewModelMapper mapper = new GenreViewModelMapper();
GenreDetail existingGenre = await _genreRepo.GetAsync(name);
GenreItemViewModel model = mapper.MapToViewModel(existingGenre);
return(View(model));
}
public async void GetGenre_ProducesMatchingGenre_AfterAddGenreIsCalled()
{
string newGenre = Guid.NewGuid().ToString();
await repo.AddAsync(newGenre);
GenreDetail getGenreResult = await repo.GetAsync(newGenre, PublishStatus.PUBLISHED);
Assert.Equal(newGenre, getGenreResult.Name);
}
public GenreItemViewModel MapToViewModel(GenreDetail sourceObject)
{
return(new GenreItemViewModel
{
Name = sourceObject.Name,
Created = sourceObject.Created,
TotalAlbums = sourceObject.TotalAlbums,
TotalArtists = sourceObject.TotalArtists
});
}
public async Task <ActionResult> Remove(GenreItemViewModel model)
{
GenreViewModelMapper mapper = new GenreViewModelMapper();
try
{
await _genreRepo.DeleteAsync(model.Name);
this.SetBootstrapPageAlert("Success", $"Deleted genre '{model.Name}' from the database", BootstrapAlertType.success);
return(RedirectToAction(nameof(Index)));
}catch (Exception e)
{
_logger.LogError(e, "Error deleting genre");
ModelState.AddModelError(nameof(model.Name), "Error deleting genre from the database");
GenreDetail existingGenre = await _genreRepo.GetAsync(model.Name);
model = mapper.MapToViewModel(existingGenre);
}
return(View(model));
}
public async void GetGenre_ShouldReturnNull_WhenGenreExists()
{
GenreDetail result = await repo.GetAsync("UNKNOW GENRE", PublishStatus.PUBLISHED);
Assert.Null(result);
}
