// 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(); }