public async Task <IActionResult> AddNewAlbum(AlbumForCreatingDto dto)
{
try
{
if (!ModelState.IsValid)
{
return(View(dto));
}
var currentUserId = userManager.GetUserId(User);
dto.OwenerId = currentUserId;
await unitOfWork.Albums.AddAsync(dto);
if (!await unitOfWork.SaveAsync())
{
// ToDo: Implement error page
return(View("ErrorSaving"));
}
return(RedirectToAction(nameof(Index)));
}
catch (Exception ex)
{
logger.LogError(ex, "An error occurred while deleting song.");
}
// ToDo: Implement error page
return(View("ErrorSaving"));
}
public async Task <IActionResult> CreateAlbum([FromBody] AlbumForCreatingDto dto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
try
{
// Set the owner of this song to the current signedIn user
var currentUserId = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
dto.OwenerId = currentUserId;
var albumEntity = await unitOfWork.Albums.AddAsync(dto);
if (!await unitOfWork.SaveAsync())
{
throw new Exception("Creating Album failed on save.");
}
var album = mapper.Map <Album>(albumEntity);
return(StatusCode(201, album));
}
catch (Exception ex)
{
logger.LogError(ex, "An error occurred while creating album.", dto);
return(StatusCode(500));
}
}
public async Task <AlbumEntity> AddAsync(AlbumForCreatingDto dto)
{
var albumEntity = mapper.Map <AlbumEntity>(dto);
await context.Albums.AddAsync(albumEntity);
return(albumEntity);
}
public ActionResult <AlbumDto> CreateAlbumForBand(Guid bandId, [FromBody] AlbumForCreatingDto album)
{
var albumEntity = _mapper.Map <Entities.Album>(album);
_bandAlbumRepository.AddAlbum(bandId, albumEntity);
_bandAlbumRepository.Save();
var albumToReturn = _mapper.Map <AlbumDto>(albumEntity);
return(CreatedAtRoute("GetAlbumForBand", new { bandId = bandId, albumId = albumToReturn.Id }, albumToReturn));
}
public ActionResult <AlbumDto> CreateForAlbumForBand(Guid bandId, [FromBody] AlbumForCreatingDto _album)
{
if (!_bandAlbumRepository.BandExists(bandId))
{
return(NotFound());
}
var AlbumEntity = _mapper.Map <Album>(_album);
_bandAlbumRepository.AddAlbum(bandId, AlbumEntity);
_bandAlbumRepository.Save();
var AlbumToReturn = _mapper.Map <AlbumDto>(AlbumEntity);
return(CreatedAtRoute("GetAlbumForBand", new { bandId = AlbumToReturn.BandId, albumId = AlbumToReturn.Id }, AlbumToReturn));
}
public ActionResult<AlbumDto> CreateAlbumForBand(Guid bandId, [FromBody] AlbumForCreatingDto album)
{
if (!_bandAlbumRepository.BandExists(bandId))
{
return NotFound();
}
Album albumEntity = _mapper.Map<Album>(album);
_bandAlbumRepository.AddAlbum(bandId, albumEntity);
_bandAlbumRepository.Save();
AlbumDto albumToReturn = _mapper.Map<AlbumDto>(albumEntity);
return CreatedAtRoute("GetAlbumForBand", new { bandId = bandId, albumId = albumToReturn.Id }, albumToReturn);
}
public ActionResult <AlbumDto> CreateAlbumForBand(Guid bandID, [FromBody] AlbumForCreatingDto album)
{
if (!_bandAlbumRepository.BandExists(bandID))
{
return(NotFound());
}
var albumEntity = _mapper.Map <Entities.Album>(album);
_bandAlbumRepository.AddAlbum(bandID, albumEntity);
_bandAlbumRepository.Save();
var returnAlbum = _mapper.Map <AlbumDto>(albumEntity);
return(CreatedAtRoute("GetAlbumsForBand", new { bandID = bandID, albumID = returnAlbum.ID }, returnAlbum));
}
public ActionResult <AlbumsDto> CreateAlbumForBand(Guid bandId, [FromBody] AlbumForCreatingDto album)
{
if (!_bandAlbumRepository.BandExists(bandId))
{
return(NotFound());
}
var albumEntity = _mapper.Map <Entities.Album>(album);
_bandAlbumRepository.AddAlbum(bandId, albumEntity);
_bandAlbumRepository.Save();
var albumToReturn = _mapper.Map <AlbumsDto>(albumEntity);
return(CreatedAtRoute(nameof(GetAlbumForBand), new { bandId = bandId, albumId = albumToReturn.Id }, albumToReturn));
}
public ActionResult <AlbumsDto> CreateAlbumForBand(Guid bandId, [FromBody] AlbumForCreatingDto album)
{
if (!_bandAlbumRepository.BandExists(bandId))
{
return(NotFound());
}
var albumEntity = _mapper.Map <Entities.Album>(album); //map to a object the database understands
_bandAlbumRepository.AddAlbum(bandId, albumEntity);
_bandAlbumRepository.Save();
var albumToReturn = _mapper.Map <AlbumsDto>(albumEntity);
return(CreatedAtRoute("GetAlbumForBand",
new { bandId = bandId, albumId = albumToReturn.Id }, albumToReturn)); //return a location header and 201 created response
}
public async Task <ActionResult <AlbumDto> > CreateNewAlbum(Guid bandId, [FromBody] AlbumForCreatingDto album)
{
// Checking if the band Exist
if (!await _bandAlbumRepository.BandExists(bandId))
{
return(NotFound());
}
var albumEntity = _mapper.Map <Album>(album);
_bandAlbumRepository.AddAlbum(bandId, albumEntity);
await _bandAlbumRepository.Save();
var albumToReturn = _mapper.Map <AlbumDto>(albumEntity);
return(CreatedAtRoute(
"GetAlbumForBand",
new { bandId = bandId, albumId = albumToReturn.Id },
albumToReturn
));
}
public async Task Add_Album_Should_Persiste()
{
using (var factory = new MusicStoreContextFactory())
{
using (var context = factory.CreateMusicStoreContext())
{
var unitOfWork = new UnitOfWork(context, _mapper);
var album = new AlbumForCreatingDto
{
Name = "First Album"
};
await unitOfWork.Albums.AddAsync(album);
await unitOfWork.SaveAsync();
}
using (var context = factory.CreateMusicStoreContext())
{
Assert.NotNull(context.Albums.First());
}
}
}
