public IActionResult AddAlbum(AlbumEditViewModel AlbumEditViewModel)
{
// Custom validation rules
if (ModelState.GetValidationState("Album.Price") == ModelValidationState.Valid &&
AlbumEditViewModel.Album.Price < 0)
{
ModelState.AddModelError(nameof(AlbumEditViewModel.Album.Price),
"The price of the Album should be higher than 0.");
}
if (AlbumEditViewModel.Album.IsAlbumOfTheWeek && !AlbumEditViewModel.Album.InStock)
{
ModelState.AddModelError(nameof(AlbumEditViewModel.Album.IsAlbumOfTheWeek),
"Only Albums that are in stock should be Album of the Week.");
}
AlbumEditViewModel.Album.CategoryId = AlbumEditViewModel.CategoryId;
//Basic validation
if (ModelState.IsValid)
{
_AlbumRepository.CreateAlbum(AlbumEditViewModel.Album);
return(RedirectToAction("Index"));
}
return(View(AlbumEditViewModel));
}
public ActionResult Edit(AlbumEditViewModel albumViewModel)
{
if (ModelState.IsValid)
{
try
{
var album = new Album()
{
AlbumArtUrl = albumViewModel.AlbumArtUrl,
AlbumId = albumViewModel.AlbumId,
ArtistId = albumViewModel.ArtistId,
GenreId = albumViewModel.GenreId,
//Note lack of price in view model
Price = 9.99m,
Title = albumViewModel.Title
};
_db.Entry(album).State = EntityState.Modified;
_db.SaveChanges();
return(RedirectToAction("Index"));
}
catch (DbEntityValidationException ex)
{
foreach (var result in ex.EntityValidationErrors)
{
foreach (var error in result.ValidationErrors)
{
ModelState.AddModelError(error.PropertyName, error.ErrorMessage);
}
}
}
}
return(View(albumViewModel));
}
public ActionResult Edit(AlbumEditViewModel viewModel)
{
// Unable to continue if viewmodel is null because we need the ID at least
if (viewModel == null || viewModel.EditedAlbum == null)
{
log.Warn("Viewmodel was null");
return(HttpStatusCodeResult(HttpStatusCode.BadRequest, "Viewmodel was null - probably JavaScript is disabled"));
}
try {
viewModel.CheckModel();
} catch (InvalidFormException x) {
AddFormSubmissionError(x.Message);
}
var model = viewModel.EditedAlbum;
// Note: name is allowed to be whitespace, but not empty.
if (model.Names != null && model.Names.All(n => n == null || string.IsNullOrEmpty(n.Value)))
{
ModelState.AddModelError("Names", AlbumValidationErrors.UnspecifiedNames);
}
if (model.OriginalRelease != null && model.OriginalRelease.ReleaseDate != null && !OptionalDateTime.IsValid(model.OriginalRelease.ReleaseDate.Year, model.OriginalRelease.ReleaseDate.Day, model.OriginalRelease.ReleaseDate.Month))
{
ModelState.AddModelError("ReleaseYear", "Invalid date");
}
var coverPicUpload = Request.Files["coverPicUpload"];
var pictureData = ParsePicture(coverPicUpload, "CoverPicture");
if (coverPicUpload == null)
{
AddFormSubmissionError("Cover picture was null");
}
if (model.Pictures == null)
{
AddFormSubmissionError("List of pictures was null");
}
if (coverPicUpload != null && model.Pictures != null)
{
ParseAdditionalPictures(coverPicUpload, model.Pictures);
}
if (!ModelState.IsValid)
{
return(View(CreateAlbumEditViewModel(model.Id, model)));
}
try {
queries.UpdateBasicProperties(model, pictureData);
} catch (InvalidPictureException) {
ModelState.AddModelError("ImageError", "The uploaded image could not processed, it might be broken. Please check the file and try again.");
return(View(CreateAlbumEditViewModel(model.Id, model)));
}
return(RedirectToAction("Details", new { id = model.Id }));
}
// GET: Albums/Edit/5
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var currentUser = await GetCurrentUserAsync();
var album = await _context.Albums.Where(a => a.UserId == currentUser.Id).FirstOrDefaultAsync(a => a.Id == id);
if (album == null)
{
return(NotFound());
}
var AlbumEditViewModel = new AlbumEditViewModel();
List <PhotoAlbum> photoAlbums = await _context.PhotoAlbums.Where(pa => pa.AlbumId == album.Id).Include(pa => pa.Photo).ToListAsync();
AlbumEditViewModel.PhotoAlbums = photoAlbums;
AlbumEditViewModel.Album = album;
return(View(AlbumEditViewModel));
}
private void GrabarAlbum(AlbumEditViewModel model)
{
var album = db.Albums.Single(x => x.AlbumId == model.AlbumId);
album.Title = model.Titulo;
album.Thumbnail = model.Caratula;
album.ThumbnailExtension = model.CaratulaExtension;
db.Albums.Update(album);
db.Commit();
}
public IActionResult Edit(int id)
{
Album album = _context.Albums.Include(x => x.Nummers).FirstOrDefault(y => y.Id == id);
AlbumEditViewModel model = new AlbumEditViewModel()
{
Foto = album.AlbumFoto, Naam = album.Naam, Id = id
};
return(View(model));
}
//public IActionResult EditAlbum([Bind("Album")] AlbumEditViewModel AlbumEditViewModel)
public IActionResult EditAlbum(AlbumEditViewModel AlbumEditViewModel)
{
AlbumEditViewModel.Album.CategoryId = AlbumEditViewModel.CategoryId;
if (ModelState.IsValid)
{
_AlbumRepository.UpdateAlbum(AlbumEditViewModel.Album);
return(RedirectToAction("Index"));
}
return(View(AlbumEditViewModel));
}
public ActionResult Edit(AlbumEditViewModel viewModel)
{
if (viewModel == null)
{
return(HttpStatusCodeResult(HttpStatusCode.BadRequest, "Viewmodel was null - probably JavaScript is disabled"));
}
var model = viewModel.EditedAlbum;
// Note: name is allowed to be whitespace, but not empty.
if (model.Names != null && model.Names.All(n => string.IsNullOrEmpty(n.Value)))
{
ModelState.AddModelError("Names", AlbumValidationErrors.UnspecifiedNames);
}
if (model.OriginalRelease != null && model.OriginalRelease.ReleaseDate != null && !OptionalDateTime.IsValid(model.OriginalRelease.ReleaseDate.Year, model.OriginalRelease.ReleaseDate.Day, model.OriginalRelease.ReleaseDate.Month))
{
ModelState.AddModelError("ReleaseYear", "Invalid date");
}
var coverPicUpload = Request.Files["coverPicUpload"];
var pictureData = ParsePicture(coverPicUpload, "CoverPicture");
if (coverPicUpload == null)
{
AddFormSubmissionError("Cover picture was null");
}
if (model.Pictures == null)
{
AddFormSubmissionError("List of pictures was null");
}
if (coverPicUpload != null && model.Pictures != null)
{
ParseAdditionalPictures(coverPicUpload, model.Pictures);
}
try {
viewModel.CheckModel();
} catch (InvalidFormException x) {
AddFormSubmissionError(x.Message);
}
if (!ModelState.IsValid)
{
return(View(new AlbumEditViewModel(Service.GetAlbum(model.Id), PermissionContext, model)));
}
queries.UpdateBasicProperties(model, pictureData);
return(RedirectToAction("Details", new { id = model.Id }));
}
// GET: Music/Edit/5
public ActionResult Edit(int id)
{
Album album = _albumRepository.GetById(id);
AlbumEditViewModel albumModel = new AlbumEditViewModel();
albumModel.Name = album.Name;
albumModel.Musics = album.Musics;
albumModel.ExistingPhotoPath = album.Image;
albumModel.Id = album.AlbumId;
albumModel.Type = album.Type;
return(View(albumModel));
}
public IActionResult AddAlbum()
{
var categories = _categoryRepository.Categories;
var AlbumEditViewModel = new AlbumEditViewModel
{
Categories = categories.Select(c => new SelectListItem()
{
Text = c.CategoryName, Value = c.CategoryId.ToString()
}).ToList(),
CategoryId = categories.FirstOrDefault().CategoryId
};
return(View(AlbumEditViewModel));
}
public void GrabarAlbum(AlbumEditViewModel model, Imagen imagen)
{
if (imagen == null)
{
GrabarAlbum(model); return;
}
var thumbnailPath = model.AlbumId.ToString().PadLeft(10, '0').GetMD5();
model.Caratula = thumbnailPath;
model.CaratulaExtension = Path.GetExtension(imagen.Nombre).Replace(".", "");
imagen.GrabaThumbnail(model.Caratula + Path.GetExtension(imagen.Nombre));
GrabarAlbum(model);
}
public ActionResult Edit(AlbumEditViewModel model)
{
if (ModelState.IsValid)
{
// Retrieve the employee being edited from the database
Album album = _albumRepository.GetById(model.Id);
// Update the employee object with the data in the model object
album.AlbumId = model.Id;
album.Name = model.Name;
album.Type = model.Type;
// If the user wants to change the photo, a new photo will be
// uploaded and the Photo property on the model object receives
// the uploaded photo. If the Photo property is null, user did
// not upload a new photo and keeps his existing photo
if (model.Image != null)
{
// If a new photo is uploaded, the existing photo must be
// deleted. So check if there is an existing photo and delete
if (model.ExistingPhotoPath != null)
{
string filePath = Path.Combine(hostingEnvironment.WebRootPath,
"images", model.ExistingPhotoPath);
System.IO.File.Delete(filePath);
}
// Save the new photo in wwwroot/images folder and update
// PhotoPath property of the employee object which will be
// eventually saved in the database
album.Image = ProcessUploadedFile(model);
}
// Call update method on the repository service passing it the
// employee object to update the data in the database table
Album updatedArtiste = _albumRepository.Edit(album);
if (updatedArtiste != null)
{
return(RedirectToAction("index"));
}
else
{
return(NotFound());
}
}
return(View(model));
}
public ActionResult Editar(AlbumEditViewModel model, HttpPostedFileBase image)
{
string ruta = Server.MapPath("~/imagenes/Albums");
try
{
Imagen imagen = ObtenerImagen(image, ruta);
tienda.GrabarAlbum(model, imagen);
return(RedirectToAction("Index", "Home"));
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
return(View(model));
}
}
public IActionResult Edit(AlbumEditViewModel model, int id)
{
Album album = _context.Albums.FirstOrDefault(y => y.Id == id);
album.Naam = model.Naam;
if (model.FotoAanpassen != null)
{
using (MemoryStream stream = new MemoryStream())
{
model.FotoAanpassen.CopyTo(stream);
album.AlbumFoto = stream.ToArray();
}
}
_context.SaveChanges();
return(RedirectToAction("Detail", new { id = model.Id }));
}
public ActionResult Edit([Bind(Include = "AlbumId,GenreId,ArtistId,Title,Price,AlbumArtUrl")] Album album)
{
if (ModelState.IsValid)
{
db.Entry(album).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
var model = new AlbumEditViewModel()
{
Album = album,
Artists = new SelectList(db.Artists, "ArtistId", "Name", album.ArtistId),
Genres = new SelectList(db.Genres, "GenreId", "Name", album.GenreId)
};
return(View(model));
}
private string ProcessUploadedFile(AlbumEditViewModel model)
{
string uniqueFileName = null;
if (model.Image != null)
{
string uploadsFolder = Path.Combine(hostingEnvironment.WebRootPath, "images");
uniqueFileName = Guid.NewGuid().ToString() + "_" + model.Image.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
using (var fileStream = new FileStream(filePath, FileMode.Create))
{
model.Image.CopyTo(fileStream);
}
}
return(uniqueFileName);
}
public ActionResult Edit(int id)
{
if (!HttpContext.CheckAccess(
ChinookResources.AlbumActions.Edit,
ChinookResources.Album,
id.ToString()))
{
return(this.AccessDenied());
}
var album = _musicRepository.GetAlbum(id);
if (album == null)
{
return(RedirectToAction("Index"));
}
var vm = new AlbumEditViewModel(album, _musicRepository);
return(View("Edit", vm));
}
// GET: StoreManager/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Album album = db.Albums.Find(id);
if (album == null)
{
return(HttpNotFound());
}
var model = new AlbumEditViewModel()
{
Album = album,
Artists = new SelectList(db.Artists, "ArtistId", "Name", album.ArtistId),
Genres = new SelectList(db.Genres, "GenreId", "Name", album.GenreId)
};
return(View(model));
}
//public IActionResult EditAlbum([FromRoute]int AlbumId)
//public IActionResult EditAlbum([FromQuery]int AlbumId, [FromHeader] string accept)
public IActionResult EditAlbum([FromQuery] int AlbumId, [FromHeader(Name = "Accept-Language")] string accept)
{
var categories = _categoryRepository.Categories;
var Album = _AlbumRepository.Albums.FirstOrDefault(p => p.AlbumId == AlbumId);
var AlbumEditViewModel = new AlbumEditViewModel
{
Categories = categories.Select(c => new SelectListItem()
{
Text = c.CategoryName, Value = c.CategoryId.ToString()
}).ToList(),
Album = Album,
CategoryId = Album.CategoryId
};
var item = AlbumEditViewModel.Categories.FirstOrDefault(c => c.Value == Album.CategoryId.ToString());
item.Selected = true;
return(View(AlbumEditViewModel));
}
public PartialViewResult AlbumDataPartial(AlbumEditViewModel model)
{
if (this.ModelState.IsValid && model != null)
{
var album = this.albumService.GetById(model.Id);
album.TitleBg = model.TitleBg;
album.TitleEn = model.TitleEn;
album.DescriptionBg = model.DescriptionBg;
album.DescriptionEn = model.DescriptionEn;
album.Access = model.Access;
this.albumService.Update(album);
var result =
this.albumService.GetAllReqursive().Where(a => a.Id == album.Id).To <AlbumEditViewModel>().First();
return(this.PartialView("_AlbumDataPartial", result));
}
return(this.PartialView("_AlbumDataPartial", model));
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
_vm = (Application.Current as App).Container.GetService <AlbumEditViewModel>();
var vm = e.Parameter as AlbumViewModel;
if (vm != null)
{
_vm.Id = vm.Id;
_vm.Title = vm.Title;
_vm.ArtistId = vm.ArtistId;
_vm.ArtistName = vm.ArtistName;
_vm.Year = vm.Year;
_vm.Cover = vm.Cover;
}
_vm.BackCommand = new RelayCommand(o => Frame.GoBack());
_vm.LoadArtists();
DataContext = _vm;
base.OnNavigatedTo(e);
}
public ActionResult Edit(AlbumEditViewModel editModel)
{
if (ModelState.IsValid)
{
var updateSucceded = this.AlbumService.EditAlbum(editModel);
if (updateSucceded)
{
return this.RedirectToAction("Index");
}
}
return this.View(editModel);
}
