// Returns a movie from a account user.
public void Checkin(int movieAssestId)
{
var rentalHistoryrecord = _context.RentalCheckoutHistories
.FirstOrDefault(rh => rh.RefMovieAssestId == movieAssestId);
if (rentalHistoryrecord == null)
{
return;
}
var returnDate = DateTime.Now;
var rentalCheckout = _context.RentalCheckouts
.FirstOrDefault(rc => rc.RefMovieAssestId == movieAssestId);
rentalCheckout.MovieAssest.Checkedout = false;
_context.Update(rentalCheckout);
rentalHistoryrecord.ReturnDate = returnDate;
_context.Update(rentalHistoryrecord);
_context.SaveChanges();
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name")] Rate rate)
{
if (id != rate.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(rate);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RateExists(rate.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(rate));
}
public IActionResult Edit(Movie movie)
{
if (ModelState.IsValid)
{
_db.Update(movie);
_db.SaveChanges();
var MovieId = movie.Id;
string wwrootPath = _hostingEnvironment.WebRootPath;
var files = HttpContext.Request.Form.Files;
var SavedMovie = _db.Movies.Find(MovieId);
if (files.Count != 0)
{
var ImagePath = @"images\";
var Extension = Path.GetExtension(files[0].FileName);
var RelativeImagePath = ImagePath + MovieId + Extension;
var AbsImagePath = Path.Combine(wwrootPath, RelativeImagePath);
using (var fileStream = new FileStream(AbsImagePath, FileMode.Create))
{
files[0].CopyTo(fileStream);
}
SavedMovie.ImagePath = RelativeImagePath;
_db.SaveChanges();
}
return(RedirectToAction(nameof(Index)));
}
return(View(movie));
}
public async Task <IActionResult> Edit(int id, [Bind("ActorId,ActorFirstName,ActorLastName,ActorGender")] Actor actor)
{
if (id != actor.ActorId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(actor);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ActorExists(actor.ActorId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(actor));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,FirstName,LastName,Gender,DateOfBirth,DateOfDeath")] Persons persons)
{
if (id != persons.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(persons);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PersonsExists(persons.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(persons));
}
public async Task <IActionResult> Edit(int id, [Bind("MovieID,Category,Title,Year,Director,Rating,Edited,LentTo,Notes")] MovieResponse movieResponse)
{
if (id != movieResponse.MovieID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(movieResponse);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieResponseExists(movieResponse.MovieID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(movieResponse));
}
public async Task <IActionResult> Edit(int id, [Bind("RatingId,MovieRatings,MovieId")] RatingModel ratingModel)
{
if (id != ratingModel.RatingId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(ratingModel);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RatingModelExists(ratingModel.RatingId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["MovieId"] = new SelectList(_context.MovieModels, "MovieId", "MovieName", ratingModel.MovieId);
return(View(ratingModel));
}
public async Task <IActionResult> Edit(int id, [Bind("MovieId,MovieTitle,MovieYear,MovieLanguage,MoviePath,MovieCoverImage")] Movie movie)
{
if (id != movie.MovieId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(movie);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieExists(movie.MovieId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(movie));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Title,Genre,Price,ReleaseDate,Rating")] Movie movie) //if its bind after we can change that.
{
if (id != movie.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(movie);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieExists(movie.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(movie));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name,Description,Year,Producer,AuthorId,NewPoster")] MovieViewModel movieVM)
{
if (id != movieVM.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var movie = _mapper.Map <MovieModel>(movieVM);
try
{
_context.Update(movie);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieExists(movie.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["AuthorId"] = new SelectList(_context.Users, "Id", "Id", movieVM.AuthorId);
return(View(movieVM));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Title,Released,RunTime,Plot,FormatId,RateId")] Movie movie)
{
if (id != movie.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(movie);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieExists(movie.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["FormatId"] = new SelectList(_context.Format, "Id", "Name", movie.FormatId);
ViewData["RateId"] = new SelectList(_context.Rate, "Id", "Name", movie.RateId);
return(View(movie));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Title,Genre,Runtime")] Movies movies)
{
if (id != movies.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(movies);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MoviesExists(movies.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(movies));
}
public async Task <IActionResult> Edit(int id, [Bind("DirectorId,FirtsName,LastName,Email")] Director director)
{
if (id != director.DirectorId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(director);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DirectorExists(director.DirectorId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(director));
}
public async Task <IActionResult> Edit(int id, MovieEditViewModel vm)
{
if (!TryValidateModel(vm))
{
return(View(vm));
}
Movie domainMovie = await _movieDbContext.Movies.Include(m => m.MovieTags).FirstOrDefaultAsync(m => m.Id == id);
_movieDbContext.MovieTags.RemoveRange(domainMovie.MovieTags);
domainMovie.Title = vm.Title;
domainMovie.Description = vm.Description;
domainMovie.Genre = vm.Genre;
domainMovie.ReleaseDate = vm.ReleaseDate;
domainMovie.MovieTags = vm.SelectedTags.Select(tagId => new MovieTag()
{
TagId = tagId
}).ToList();
_movieDbContext.Update(domainMovie);
await _movieDbContext.SaveChangesAsync();
return(RedirectToAction("Detail", new { Id = id }));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Title,Description,MovieLenght,Raiting,DateReleased,PosterPath")] Movie movie)
{
if (id != movie.MovieID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(movie);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieExists(movie.MovieID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(movie));
}
public async Task <IActionResult> AddOrEdit(int id, [Bind("Title,ReleaseDate,Genre,Price")] Movie movie)
{
if (ModelState.IsValid)
{
//Insert
if (id == 0)
{
_context.Add(movie);
await _context.SaveChangesAsync();
}
//Update
else
{
try
{
_context.Update(movie);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieModelExists(movie.Id))
{
return(NotFound());
}
else
{
throw;
}
}
}
return(Json(new { isValid = true, html = await Helper.RenderRazorViewToStringAsync(this, "_ViewAll", _context.Movies.ToList()) }));
}
return(Json(new { isValid = false, html = await Helper.RenderRazorViewToStringAsync(this, "AddOrEdit", movie) }));
}
public async Task <IActionResult> Edit(int id, [Bind("MovieId,Category,Title,YearReleased,DirectorName,MovieRating,IsEdited,IsLentTo,Notes")] AddMovie addMovie)
{
if (id != addMovie.MovieId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(addMovie);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AddMovieExists(addMovie.MovieId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(addMovie));
}
public async Task <IActionResult> Edit(int id, [Bind("MovieId,GenreId")] MovieGenre movieGenre)
{
if (id != movieGenre.MovieId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(movieGenre);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieGenreExists(movieGenre.MovieId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["GenreId"] = new SelectList(_context.Genres, "GenreId", "GenreId", movieGenre.GenreId);
ViewData["MovieId"] = new SelectList(_context.Movies, "MovieId", "MovieId", movieGenre.MovieId);
return(View(movieGenre));
}
public int Update(Movie newMovie)
{
_context.Update(newMovie);
var count = _context.SaveChanges();
return(count);
}
public async Task <IActionResult> Edit(int id, [Bind("MovieId,Category,Title,Year,Director,Rating,Edited,Lent_to,Notes")] MovieInfo movieInfo)
{
if (id != movieInfo.MovieId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(movieInfo);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieInfoExists(movieInfo.MovieId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Collection"));
}
return(View());
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Firstname,Lastname,BirthOfDate")] Author author)
{
if (id != author.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(author);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AuthorExists(author.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(author));
}
public IActionResult Edit(Title title)
{
if (ModelState.IsValid)
{
_db.Update(title);
_db.SaveChanges();
return(RedirectToAction(nameof(Index)));
}
return(View(title));
}
public IActionResult EditFavorite(FavoriteMovies editFavorite)
{
FavoriteMovies originFav = _context.FavoriteMovies.Find(editFavorite.Id);
if (ModelState.IsValid)
{
originFav.UserRating = editFavorite.UserRating;
_context.Entry(originFav).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
_context.Update(originFav);
_context.SaveChanges();
}
return(RedirectToAction("ListFavorites"));
}
public async Task <bool> EditActorAsync(Actor model)
{
var actor = await _dbContext.Actors.FindAsync(model.Id);
if (actor is null)
{
return(false);
throw new ArgumentException("Actor does not exist");
}
actor.Name = model.Name;
actor.Born = model.Born;
_dbContext.Update(actor);
await _dbContext.SaveChangesAsync();
return(true);
}
public IActionResult EditMovie(MovieModel movie)
{
_context.Update(movie);
_context.SaveChanges();
return(View("Success", movie));
}
public async Task Update(Movie movie)
{
_context.Update(movie);
await _context.SaveChangesAsync();
}
