public ICommandResult Handle(CreateAlbumCommand command)
{
var categoryQuery = _categoryRepository.GetById(command.CategoryId);
var genderQuery = _genderRepository.GetById(command.GenderId);
Gender gender = new Gender(genderQuery.Id, genderQuery.Title, genderQuery.Description);
Category category = new Category(categoryQuery.Id, categoryQuery.Title, categoryQuery.Description);
Album album = new Album(command.Title, gender, category, command.Image);
AddNotifications(album.Notifications);
if (Invalid)
{
return(new CommandResult(false, MessagesUtil.FormFail, Notifications));
}
bool result = _repository.Create(album);
if (!result)
{
return(new CommandResult(false, MessagesUtil.CreateError, Notifications));
}
return(new CommandResult(true, MessagesUtil.CreatedSuccess));
}
public void Post(AlbumDTO value)
{
Album model = new Album()
{
Name = value.Name,
ReleaseYear = value.ReleaseYear,
StudioId = value.StudioId
};
IAlbumRepository.Create(model);
for (int i = 0; i < value.ArtistId.Count; i++)
{
ArtistAlbum ArtistAlbum = new ArtistAlbum()
{
AlbumId = model.Id,
ArtistId = value.ArtistId[i]
};
IArtistAlbumRepository.Create(ArtistAlbum);
}
for (int i = 0; i < value.SongId.Count; i++)
{
SongAlbum SongAlbum = new SongAlbum()
{
AlbumId = model.Id,
SongId = value.ArtistId[i]
};
ISongAlbumRepository.Create(SongAlbum);
}
}
public ActionResult EditAlbum(Album album, HttpPostedFileBase Image = null, int AuthorId = 0, int CategoryId = 0)
{
if (ModelState.IsValid)
{
if (Image != null)
{
string fileName = Path.GetFileName(Image.FileName);
string filePath = "~/Content/Images" + fileName;
album.ImagePath = filePath;
Image.SaveAs(Server.MapPath(filePath));
}
if (CategoryId != 0)
{
album.CategoryId = CategoryId;
}
if (AuthorId != 0)
{
album.AuthorId = AuthorId;
}
albumRepository.Create(album);
string message = "Action Succeded";
return(RedirectToAction("Albums", new { message = message }));
}
else
{
ViewBag.Authors = authorRepository.GetList();
ViewBag.Categories = categoryRepository.GetList();
return(View(album));
}
}
public async Task <ActionResult <Album> > Post([FromBody] Album album)
{
album.Id = await _repo.GetNextId();
await _repo.Create(album);
return(new OkObjectResult(album));
}
public async Task <IActionResult> CreateAlbum([FromRoute] Guid artistId, [FromBody] AlbumForCreationDto albumToCreate)
{
var albumEntity = Mapper.Map <Album>(albumToCreate);
albumEntity.Id = Guid.NewGuid();
albumEntity.ArtistId = artistId;
_albumRepository.Create(albumEntity);
if (!await _albumRepository.SaveChangesAsync())
{
throw new Exception($"adding album to artist {artistId} failed");
}
return(CreatedAtRoute("GetAlbum", new { artistId, id = albumEntity.Id }, albumEntity));
}
public void Create(AlbumEntity album)
{
albumRepository.Create(new DalAlbum()
{
Name = album.Name,
UserId = album.UserId,
CreationDate = album.CreationDate
});
uow.Commit();
}
public ActionResult <Model.Album> Create([FromBody] Model.RawAlbum value)
{
try
{
var created = repository.Create(value);
return(CreatedAtAction(nameof(GetDetails), new { name = created.Name, owner = created.Owner }, created));
} catch (ArgumentException e)
{
return(BadRequest(new { error = e.Message }));
}
}
public void SaveAlbum(Album album)
{
try
{
_albumRepository.Create(album);
_unitOfWork.SaveChanges();
}
catch (Exception ex)
{
LogError(ex);
}
}
public IActionResult Create(AlbumViewModel albumViewModel)
{
if (!ModelState.IsValid)
{
albumViewModel.Bands = _bandRepository.GetAll();
return(View(albumViewModel));
}
_albumRepository.Create(albumViewModel.Album);
return(RedirectToAction("List"));
}
public async Task <IActionResult> Create([Bind("AlbumId,GenreId,ArtistId,Title,Price,AlbumArtUrl")] Album album, [FromServices] IAlbumRepository albumRepository, CancellationToken cancellationToken = default)
{
if (ModelState.IsValid)
{
album = await albumRepository.Create(album, cancellationToken);
cancellationToken.ThrowIfCancellationRequested();
return(RedirectToAction("Index"));
}
await BuildCreateView(cancellationToken);
return(View(album));
}
public int CreateAlbum(businessModels.FullAlbum model)
{
model.AuthorId = User.Identity.GetUserId();
model.CreationDate = DateTime.Now;
model.ModificationDate = DateTime.Now;
if (ModelState.IsValid)
{
//creating photos
var album = Mapper.Map <Album>(model);
albumRepository.Create(album);
return(album.Id);
}
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
public ActionResult Create(Album a)
{
if (ModelState.IsValid)
{
try
{
var album = _albumRepository.Create(a);
return(RedirectToAction("Details", new { id = album.Id }));
}
catch (Exception ex)
{
return(View(a));
}
}
return(RedirectToAction("Index"));
}
public Album Create(string albumName, string artistName, int genreId, Int16 price, System.Web.HttpPostedFileBase cover)
{
Album album = new Album
{
Name = albumName,
Artist = ArtistRepository.CreateOrGet(artistName),
GenreId = genreId,
CreationDateTime = DateTime.Now,
Price = price
};
AlbumRepository.Create(album);
UploadResizeAndSave(ref album, cover);
return(album);
}
public Album UpdateAlbum(Album album)
{
return(ExecuteFaultHandledOperation(() =>
{
IAlbumRepository albumRepository = _genericRepositoryFactory.GetGenericRepository <IAlbumRepository>();
Album updatedEntity = null;
if (album.AlbumId == 0)
{
updatedEntity = albumRepository.Create(album).Result;
}
else
{
updatedEntity = albumRepository.Update(album).Result;
}
return updatedEntity;
}));
}
public void CreateAlbum(AlbumEntity album)
{
albumRepository.Create(album.ToDal());
uow.Commit();
}
public void Create(Album album)
{
_albumRepository.Create(album);
}
public void Create(IElementSettings settings, IUnitOfWork unitOfWork = null)
{
_albumRepository.Create((AlbumSettings)settings, unitOfWork);
}
public void Criar(Album entity)
{
_albumRepository.Create(entity);
}
public ActionResult Create(Album album)
{
albumRepo.Create(album);
return(RedirectToAction("Index"));
}
public bool Insert(Album album)
{
_repository.Create(album);
return(_repository.SaveChanges());
}