public async Task <AlbumResponse> SaveAsync(Album album)
{
try
{
foreach (var albumGenre in album.AlbumGenres)
{
albumGenre.DateAdded = DateTime.Now;
}
foreach (var track in album.Tracks)
{
track.DateAdded = DateTime.Now;
}
album.DateAdded = DateTime.Now;
await _albumRepository.AddAsync(album);
await _unitOfWork.CompleteAsync();
var albumResponse = await GetByIdAsync(album.AlbumId);
return(new AlbumResponse(albumResponse.Album));
} catch (Exception ex) {
return(new AlbumResponse($"An error occurred when saving the album, exception: {ex.Message}"));
}
}
public async Task <AlbumVm> Handle(CreateAlbum request, CancellationToken cancellationToken)
{
var album = new Album(Guid.NewGuid(), request.Name, request.ReleaseYear, request.Duration, request.ArtistId.Value);
string imageUrl;
if (request.Poster?.HasValue() == true)
{
if (!string.IsNullOrEmpty(album.Poster))
{
await _fileUtils.RemoveByUrlAsync(album.Poster);
}
var fileName = $"albums/{Guid.NewGuid()}{request.Poster.Name.GetExtension()}";
imageUrl = await _fileUtils.UploadAsync(request.Poster, fileName);
if (imageUrl.IsNull())
{
throw new Exception("Erro ao Importar o poster");
}
}
else
{
imageUrl = album.Poster;
}
album.Poster = imageUrl;
await _albumRepository.AddAsync(album);
return(album.ToVm());
}
public async Task <IActionResult> Add(CreateAlbumViewModel model)
{
AlbumViewModelMapper mapper = new AlbumViewModelMapper();
PublishStatus flags = PublishStatus.PUBLISHED | PublishStatus.UNPUBLISHED;
var artistNames = await _artistRepo.ListNamesAsync(flags);
model.ArtistOptions = artistNames
.Select(x => new SelectListItem
{
Text = x.Name,
Value = x.Id.ToString(),
Selected = x.Id == model.ArtistId
}).ToList();
List <CheckBoxListItem> groupOptions = (await _albumGroupRepo.ListAsync())
.Select(x => new CheckBoxListItem
{
Label = x.Name,
Value = x.Key,
IsSelected = model.Groups.Any(grp => grp.IsSelected && grp.Value == x.Key)
}).ToList();
model.Groups = groupOptions;
if (ModelState.IsValid)
{
int?createdImageId = null;
if (model.CoverImage != null && model.CoverImage.Length > 0)
{
using (MemoryStream ms = new MemoryStream())
{
await model.CoverImage.CopyToAsync(ms);
ImageReferenceDetail imageRef = await _imageRepo.AddAsync(new ImageReferenceDetail
{
Data = ms.ToArray(),
FileName = model.CoverImage.FileName,
MimeType = model.CoverImage.ContentType
});
if (imageRef != null)
{
createdImageId = imageRef.Id;
}
}
}
var result = await _albumRepo.AddAsync(mapper.Map(model, createdImageId));
await _albumGroupRepo.SetGroupsForAlbum(result.Id, model.Groups.Where(g => g.IsSelected).Select(g => g.Value).ToList());
this.SetBootstrapPageAlert("Success", "Album added", BootstrapAlertType.success);
return(RedirectToAction(nameof(Index)));
}
else
{
return(View(model));
}
}
public async Task CreateAlbumAsync(AlbumDTO album)
{
if (album == null)
{
throw new ArgumentNullException();
}
Album albumToAdd = new Album(album.AlbumId, album.Title, album.Price);
await _albumRepository.AddAsync(albumToAdd);
}
public async Task <AlbumViewModel> AddAlbumAsync(AlbumViewModel newAlbumViewModel, CancellationToken ct = default(CancellationToken))
{
var album = new Album
{
Title = newAlbumViewModel.Title,
ArtistId = newAlbumViewModel.ArtistId
};
album = await _albumRepository.AddAsync(album, ct);
newAlbumViewModel.AlbumId = album.AlbumId;
return(newAlbumViewModel);
}
public async Task <IActionResult> Add([FromBody] Album album)
{
if (ModelState.IsValid)
{
try{
AlbumDetail a = await _repository.AddAsync(album);
return(CreatedAtRoute(
new { controller = "album", action = nameof(Get), id = a.Id }
, a));
}catch (RepositoryException e) {
return(BadRequest(new ApiErrorRep(e.Message)));
}catch (Exception e) {
_logger.LogError("AddAlbum", e, "Error adding album");
return(StatusCode(500, new ApiErrorRep("Unknown error")));
}
}
else
{
return(BadRequest(ModelState));
}
}
public async Task <ActionResult <AlbumViewModel> > AddAlbum([FromForm] AlbumViewModel albumViewModel)
{
if (!ModelState.IsValid)
{
return(NotFound());
}
//获取图片即封面
var image = albumViewModel.CoverImage;
var album = _mapper.Map <Album>(albumViewModel);
var relativePath = Path.Combine(album.UserId.ToString(), album.Id.ToString(), "CoverImage"); //相对地址
await FileHelper.CreateFileAsync(image, relativePath); //封面图片保存
album.CoverUrl = Path.Combine(FileHelper.BaseFilePath, relativePath, image.FileName); //最终地址保存到数据库
var result = await _albumRepository.AddAsync(album);
if (result > 0)
{
return(Ok(album));
}
else
{
return(NotFound());
}
}
public async Task <AlbumApplication> AddAsync(AlbumApplication entity)
{
var result = await _albumRepository.AddAsync(AlbumMapper.Map(entity));
return(AlbumMapper.Map(result));
}
