public IActionResult Create(int categoryId)
{
MovieCreateViewModel model = new MovieCreateViewModel();
model.LoadModelData(_unitOfWork, categoryId);
return(View(model));
}
public void ShouldReturnDefaultViewModelWithNoErrorWhenModelIsValid()
{
// Arrange
var success = new Result(ResultType.Success);
var moviesSvMock = new Mock <IMoviesService>();
moviesSvMock.Setup(x => x.AddMovie(It.IsAny <Movies>())).Returns(success);
var fakeMovie = new MovieCreateViewModel();
var sut = new MoviesController(moviesSvMock.Object);
var fakeHttpContext = new Mock <HttpContextBase>();
sut.ControllerContext = new ControllerContext
{
Controller = sut,
HttpContext = fakeHttpContext.Object
};
var mapper = new AutoMapperConfig();
mapper.Execute(Assembly.GetExecutingAssembly());
Mapper.Initialize(cfg =>
cfg.CreateMap <MovieCreateViewModel, Movies>());
// Act & Assert
sut
.WithCallTo(c => c.Create(fakeMovie))
.ShouldRenderDefaultView()
.WithModel <MovieCreateViewModel>(x => Assert.AreEqual(x.Result.ResulType, ResultType.Success));
}
public async Task <IActionResult> Create(MovieCreateViewModel model)
{
if (ModelState.IsValid)
{
string uniqueFileName = null;
if (model.Photo != null)
{
string uploadsFolder = Path.Combine(hostingEnvironment.WebRootPath, "img");
uniqueFileName = Guid.NewGuid().ToString() + "_" + model.Photo.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
FileStream fs = new FileStream(filePath, FileMode.Create);
model.Photo.CopyTo(fs);
fs.Close();
}
Movie newMovie = new Movie
{
Title = model.Title,
ReleaseDate = model.ReleaseDate,
Genre = model.Genre,
Price = model.Price,
Rating = model.Rating,
PhotoPath = uniqueFileName
};
_context.Add(newMovie);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View());
}
public IActionResult Create(MovieCreateViewModel model)
{
if (!TryValidateModel(model))
{
return(View(model));
}
foreach (var movie in _context.Movies)
{
if (model.Title == movie.Title)
{
return(View());
}
}
var m = new Movie()
{
Title = model.Title,
Cover = model.Cover,
Description = model.Description,
Length = model.Length,
Regisseurs = model.Regisseurs,
ReleaseDate = model.ReleaseDate
};
foreach (var item in model.Genres.Where(x => x.Checked == true))
{
}
_context.InsertMovie(m);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Create([Bind("MovieId,Title,ReleaseDate,GenreID,Price,Photo")] MovieCreateViewModel movie)
{
if (ModelState.IsValid)
{
string uniqueFilename = null;
if (movie.Photo != null)
{
string uploadsFolder = Path.Combine(hostingEnvironment.WebRootPath, "images");
uniqueFilename = Guid.NewGuid().ToString() + "_" + movie.Photo.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFilename);
movie.Photo.CopyTo(new FileStream(filePath, FileMode.Create));
}
Movie m = new Movie
{
Title = movie.Title,
ReleaseDate = movie.ReleaseDate,
GenreID = movie.GenreID,
Price = movie.Price,
PhotoPath = uniqueFilename
};
_context.Add(m);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["GenreID"] = new SelectList(_context.Genre, "GenreID", "Description", movie.GenreID);
return(View(movie));
}
public IActionResult Create(MovieCreateViewModel model)
{
if (!TryValidateModel(model))
{
return(View());
}
Movie movieToAdd = new Movie
{
Titel = model.Titel,
Beschrijving = model.Beschrijving,
Speelduur = model.Speelduur
};
_movieService.Insert(movieToAdd);
foreach (var genre in model.GenreList)
{
if (genre.Checked)
{
_genreService.AssignGenre(movieToAdd, genre.Naam);
}
}
//List<string> regisseurList = model.Regisseurs.ToList();
//foreach (var reg in regisseurList)
//{
// _regisseurService.HandleRegisseurCreate(movieToAdd, reg);
//}
_regisseurService.HandleRegisseurCreate(movieToAdd, model.Regisseurs);
return(RedirectToAction("Details", new { movieId = movieToAdd.Id }));
}
public IActionResult Create()
{
List <MovieGenreListViewModel> genreList = new List <MovieGenreListViewModel>();
foreach (var genre in _genreService.Get())
{
genreList.Add(new MovieGenreListViewModel()
{
Naam = genre.Naam
});
}
;
List <string> regList = new List <string>();
foreach (var reg in _regisseurService.Get())
{
regList.Add(reg.Naam);
}
MovieCreateViewModel model = new MovieCreateViewModel()
{
GenreList = genreList,
RegisseurList = regList
};
return(View(model));
}
public async Task <IActionResult> Create([Bind("Id,Title,ReleaseDate,Genre,Price,Rating,Image")] MovieCreateViewModel movie)
{
if (ModelState.IsValid)
{
string uniqueFileName = null;
if (movie.Image != null)
{
string uploadsFolder = Path.Combine(hostingEnvironment.WebRootPath, "Images");
uniqueFileName = Guid.NewGuid().ToString().Length + "_" + movie.Image.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
movie.Image.CopyTo(new FileStream(filePath, FileMode.Create));
}
Movie newMovie = new Movie
{
Title = movie.Title,
ReleaseDate = movie.ReleaseDate,
Price = movie.Price,
Genre = movie.Genre,
Rating = movie.Rating,
ImagePath = uniqueFileName
};
_context.Add(newMovie);
//_context.Add(movie);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(movie));
}
public async Task <MovieCreateViewModel> LoadGenresAndPersonsToCreateViewModel(MovieCreateViewModel viewModel = null)
{
if (viewModel == null)
{
viewModel = new MovieCreateViewModel();
}
var genres = await _unitOfWork.Genres.GetAllOrderedBy("name", "desc").ToListAsync();
var persons = await _unitOfWork.Persons.GetAllOrderedBy(null, "last_name", "asc").ToListAsync();
viewModel.Genres = genres.Select(genre => new SelectListItem
{
Text = genre.Name,
Value = genre.Id.ToString()
}).ToList();
viewModel.Persons = persons.Select(person => new SelectListItem
{
Text = person.FullName,
Value = person.Id.ToString()
}).ToList();
return(viewModel);
}
//Old One ---- public async Task<IActionResult> Create([Bind("Id,Title,ReleaseDate,Genre,Price,Rating,PhotoPath")] Movie movie)
public async Task <IActionResult> Create([Bind("Id,Title,ReleaseDate,Genre,Price,Rating,PhotoPath,Photo")] MovieCreateViewModel model)
{
if (ModelState.IsValid)
{
string uniqueFileName = null;
if (model.Photo != null)
{
string uploadsFolder = Path.Combine(hostingEnvironment.WebRootPath, "images");
uniqueFileName = Guid.NewGuid().ToString() + "_" + model.Photo.FileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
model.Photo.CopyTo(new FileStream(filePath, FileMode.Create));
}
Movie movie = new Movie
{
Title = model.Title,
ReleaseDate = model.ReleaseDate,
Genre = model.Genre,
Price = model.Price,
Rating = model.Rating,
PhotoPath = uniqueFileName
};
_context.Add(movie);
await _context.SaveChangesAsync();
return(RedirectToAction("Details", new { id = movie.Id }));
}
return(View(model));
}
public IActionResult Create([Bind("MovieId,Title,Runtime,Year,Poster,Description")] MovieCreateViewModel movie)
{
if (!ModelState.IsValid)
{
return(View(movie));
}
string uniqueFileName = null;
if (movie.Poster != null)
{
string uploadsFolder = Path.Combine(iHostingEnvironment.WebRootPath, "images");
string fileName = movie.Poster.FileName;
uniqueFileName = Guid.NewGuid().ToString() + "_" + fileName;
string filePath = Path.Combine(uploadsFolder, uniqueFileName);
movie.Poster.CopyTo(new FileStream(filePath, FileMode.Create));
}
var movieToAdd = new Movie()
{
Title = movie.Title,
Runtime = movie.Runtime,
Year = movie.Year,
PosterPath = uniqueFileName,
Description = movie.Description,
};
_repository.Add(movieToAdd);
return(RedirectToAction(nameof(Index), "Movies"));
}
public IActionResult Create()
{
MovieCreateViewModel model = new MovieCreateViewModel();
List <MovieGenreViewModel> movieGenreList = new List <MovieGenreViewModel>();
foreach (var genre in _database.MovieGenres)
{
movieGenreList.Add(new MovieGenreViewModel {
Name = genre.Name
});
}
model.genreNames = movieGenreList;
List <MovieArtistListViewModel> crewMembersList = new List <MovieArtistListViewModel>();
foreach (var artist in _database.CrewMembers)
{
crewMembersList.Add(new MovieArtistListViewModel {
ArtistName = artist.Name
});
}
model.artistNames = crewMembersList;
model.ReleaseDate = DateTime.Now;
return(View(model));
}
public IActionResult Create()
{
MovieCreateViewModel vm = new MovieCreateViewModel();
vm.Releasedate = DateTime.Now;
return(View(vm));
}
public async Task <IActionResult> Create()
{
MovieCreateViewModel vm = new MovieCreateViewModel();
vm.ReleaseDate = DateTime.Now;
var watchStatuses = await _movieDbContext.WatchStatuses.ToListAsync();
foreach (WatchStatus watchStatus in watchStatuses)
{
vm.WatchStatuses.Add(new SelectListItem()
{
Value = watchStatus.Id.ToString(),
Text = watchStatus.Name
});
}
var tags = await _movieDbContext.Tags.ToListAsync();
vm.Tags = tags.Select(tag => new SelectListItem()
{
Value = tag.Id.ToString(), Text = tag.Name
}).ToList();
return(View(vm));
}
public IActionResult Create(MovieCreateViewModel movie)
{
if (ModelState.IsValid)
{
string uniqueFileName = null;
if (movie.Poster != null)
{
//get wwwroot path then combine to define were to upload
// filenames with same name use guid global unique identifier, same name will overide each other
string uploadfolder = Path.Combine(HostingEnvironment.WebRootPath, "images");
uniqueFileName = Guid.NewGuid().ToString() + "_" + movie.Poster.FileName;
string filePath = Path.Combine(uploadfolder, uniqueFileName);
//copyto is iform file method
movie.Poster.CopyTo(new FileStream(filePath, FileMode.Create));
}
Movie newMovie = new Movie()
{
Title = movie.Title,
Length = movie.Length,
Gener = movie.Gener,
RealeaseDate = movie.RealeaseDate,
PhotoPath = uniqueFileName
};
_movieRepository.Add(newMovie);
//??
return(RedirectToAction("details", new { id = newMovie.MovieId }));
}
return(View());
}
public async Task RedirectToCorrectAction_OnPost()
{
// Arrange
var movieServiceMock = new Mock <IMovieService>();
var genreServiceMock = new Mock <IGenreService>();
movieServiceMock.Setup(msm => msm.CreateMovieAsync(null, 0,
null, null, null, null))
.ReturnsAsync(new MovieViewModel());
var createModel = new MovieCreateViewModel();
var sut = new MovieManagementController(movieServiceMock.Object, genreServiceMock.Object);
// Act
var result = await sut.Create(createModel);
// Assert
Assert.IsInstanceOfType(result, typeof(RedirectToActionResult));
var redirect = (RedirectToActionResult)result;
// They are redirecting to the basic Movie Controller, not the MovieManagement one.
Assert.IsTrue(redirect.ControllerName == "Movie");
Assert.IsTrue(redirect.ActionName == "Details");
}
public async Task <IActionResult> Create(MovieCreateViewModel model)
{
if (!TryValidateModel(model))
{
return(View());
}
Movie movie = new Movie()
{
Titel = model.Titel,
Speeltijd = model.Speeltijd
};
using (var memoryStream = new MemoryStream())
{
await model.Foto.CopyToAsync(memoryStream);
movie.Foto = memoryStream.ToArray();
}
List <string> genreListItems = new List <string>();
foreach (var item in model.GenreList)
{
if (item.Checked)
{
genreListItems.Add(item.Naam);
}
}
_context.Insert(movie);
_context.AssignGenres(genreListItems, movie.Id);
return(RedirectToAction("MovieDetail", new { id = movie.Id }));
}
public async Task <IActionResult> Create()
{
var model = new MovieCreateViewModel();
var genres = await this.genreService.GetAllGenres();
model.GenreList = genres.Select(t => new SelectListItem(t.Name, t.Name)).ToList();
return(this.View(model));
}
public IActionResult Create()
{
MovieCreateViewModel mov = new MovieCreateViewModel()
{
ReleaseDate = DateTime.Today
};
return(View(mov));
}
public async Task <IActionResult> Create(MovieCreateViewModel model)
{
if (this.ModelState.IsValid)
{
var movie = await this.movieService.CreateMovieAsync(model.Name, model.Duration, model.Storyline, model.Director, model.ImageUrl, model.GenreName);
return(this.RedirectToAction("Details", "Movie", new { id = movie.Name }));
}
return(this.View(model));
}
public async Task <IActionResult> Create(MovieCreateViewModel viewModel)
{
if (!TryValidateModel(viewModel))
{
return(View(viewModel));
}
var movie = Mapper.Map <Movie>(viewModel);
await _movieService.CreateAsync(movie);
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Create(MovieCreateViewModel movie)
{
if (!TryValidateModel(movie))
{
return(View(movie));
}
string userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
Movie newMovie = new Movie()
{
Title = movie.Title,
Description = movie.Description,
ReleaseDate = movie.ReleaseDate,
Genre = movie.Genre,
WatchStatusId = movie.SelectedWatchStatus,
MovieAppUserId = userId
// MovieTag = movie.SelectedTags.Select(tag => new MovieTag() { TagId = tag }).ToList()
};
var movieTags = new List <MovieTag>();
foreach (var selectedTag in movie.SelectedTags)
{
movieTags.Add(new MovieTag()
{
TagId = selectedTag
});
}
newMovie.MovieTags = movieTags;
if (movie.Photo != null)
{
var uniqueFileName = Guid.NewGuid().ToString() + Path.GetExtension(movie.Photo.FileName);
var pathName = Path.Combine(_hostingEnvironment.WebRootPath, "pics");
var fileNameWithPath = Path.Combine(pathName, uniqueFileName);
using (var stream = new FileStream(fileNameWithPath, FileMode.Create))
{
movie.Photo.CopyTo(stream);
}
newMovie.Photo = "/pics/" + uniqueFileName;
}
_movieDbContext.Movies.Add(newMovie);
await _movieDbContext.SaveChangesAsync();
_messageService.Send("Er heeft iemand een film aangemaakt!");
return(RedirectToAction("Index"));
}
public IActionResult CreateFilm(MovieCreateViewModel model)
{
if (ModelState.IsValid)
{
string uniqueName = null;
if (model.Photo != null)
{
string root = Path.Combine(hostingEnvironment.WebRootPath + "/imgs/films");
uniqueName = Guid.NewGuid().ToString() + "_" + model.Photo.FileName;
string filePath = Path.Combine(root, uniqueName);
model.Photo.CopyTo(new FileStream(filePath, FileMode.Create));
}
else
{
ModelState.AddModelError(string.Empty, "Bạn chưa chọn hình ảnh.");
return(View(model));
}
if (DateTime.Compare(model.StartDate, model.EndDate) > 0)
{
ModelState.AddModelError(string.Empty, "Ngày kết thúc phải muộn hơn ngày bắt đầu chiếu!");
return(View(model));
}
if (model.Hour > 4)
{
ModelState.AddModelError(string.Empty, "Phim chiếu rạp không được quá 4 tiếng!");
return(View(model));
}
Movie movie = new Movie()
{
Title = model.Title,
Language = model.Language,
CateId = _movieRepository.GetIDCategory(model.Type),
Hour = model.Hour,
Director = model.Director,
Star = model.Star,
Description = model.Description,
StartDate = model.StartDate.ToString(),
EndDate = model.EndDate.ToString(),
PhotoPath = uniqueName
};
_movieRepository.AddNewMovie(movie);
}
return(View(model));
}
public IActionResult Create(MovieCreateViewModel movie)
{
if (ModelState.IsValid)
{
_movieDatabase.Insert(new Movie
{
Title = movie.Title,
Description = movie.Description,
Genre = movie.Genre,
ReleaseDate = movie.ReleaseDate
});
return(RedirectToAction("Index"));
}
return(View(movie));
}
public async Task <IActionResult> Create(MovieCreateViewModel movieCreateViewModel)
{
if (ModelState.IsValid)
{
await _movieService.CreateMovie(movieCreateViewModel);
_flashMessage.Confirmation("Movie has been created.");
return(RedirectToAction(nameof(Index)));
}
var viewModel = await _movieService.LoadGenresAndPersonsToCreateViewModel(movieCreateViewModel);
return(View(viewModel));
}
public IActionResult Create(MovieCreateViewModel NewMovie)
{
if (!TryValidateModel(NewMovie))
{
return(View(NewMovie));
}
_movieDatabase.Insert(new Movie
{
Title = NewMovie.Title,
Description = NewMovie.Description,
Genre = NewMovie.Genre,
ReleaseDate = NewMovie.ReleaseDate
});
return(RedirectToAction("index"));
}
public async Task <IActionResult> Create()
{
MovieCreateViewModel createModel = new MovieCreateViewModel();
//create selectlist of existing gneres
var genres = await _mediaWebDbContext.Genres.Select(genre => new SelectListItem()
{
Value = genre.Id.ToString(),
Text = genre.Name
}).ToListAsync();
createModel.Genres = genres;
return(View(createModel));
}
public async Task <IActionResult> Edit(int?id, MovieCreateViewModel movieCreateViewMode)
{
if (id == null)
{
return(NotFound());
}
var movie = await _context.Movie.FindAsync(id);
if (movie == null)
{
return(NotFound());
}
return(View(movieCreateViewMode));
}
private string ProcessUploadedFile(MovieCreateViewModel model)
{
string uniqueFileName = null;
if (model.Photo != null)
{
string uploadFolder = Path.Combine(_hostingEnviroment.WebRootPath, "images");
uniqueFileName = Guid.NewGuid().ToString() + "_" + model.Photo.FileName;
string filePath = Path.Combine(uploadFolder, uniqueFileName);
using (var fileStream = new FileStream(filePath, FileMode.Create))
{
model.Photo.CopyTo(fileStream);
}
}
return(uniqueFileName);
}
private string ProcessUploadedVideo(MovieCreateViewModel model)
{
string uniqueVideoFile = null;
if (model.Video != null && model.Video.Length < 3221225472)
{
string uploadfolder = Path.Combine(_hostingEnviroment.WebRootPath, "videos");
uniqueVideoFile = Guid.NewGuid().ToString() + "_" + model.Video.FileName;
string filePath = Path.Combine(uploadfolder, uniqueVideoFile);
using (var fileStream = new FileStream(filePath, FileMode.Create))
{
model.Video.CopyTo(fileStream);
}
}
return(uniqueVideoFile);
}
