public IActionResult Create(MovieCreateModel movieCreateModel)
{
#region automappersiz
Movie movie = new Movie();
movie.Name = movieCreateModel.Name;
movie.Description = movieCreateModel.Description;
movie.Length = movieCreateModel.Length;
movie.Actors = new List <ActorMovie>();
foreach (var actor in movieCreateModel.Actors)
{
ActorMovie actorMovie = new ActorMovie();
var query = _actorRepository.GetById(actor);
actorMovie.Actor = query;
actorMovie.Movie = movie;
movie.Actors.Add(actorMovie);
}
#endregion
// Movie movieResponseModel = _mapper.Map<Movie>(movieCreateModel);
//
// foreach (var actor in movieCreateModel.Actors)
// {
// ActorMovie actor1 = new ActorMovie();
// actor1.Actor = _actorRepository.GetById(actor);
// movieResponseModel.Actors.Add(actor1);
// }
//
// MovieResponseModel movieResponse = _mapper.Map<MovieResponseModel>(_movieRepository.Create(movieResponseModel));
return(Ok(movie));
}
public async Task Create(MovieCreateModel input)
{
var movie = new Movie()
{
ImageUrl = input.ImageUrl,
Title = input.Title,
Year = input.Year,
Description = input.Description,
HomePageLink = input.HomePageLink,
IMDBLink = input.IMDBLink,
TrailerLink = input.TrailerLink,
FacebookLink = input.FacebookLink,
Creater = input.Creater,
Producer = input.Producer,
Country = input.Country,
};
var movieGenre = this.genresRepository
.All()
.FirstOrDefault(x => x.Id == input.GenreId);
movie.Genres.Add(movieGenre);
await this.moviesRepository.AddAsync(movie);
await this.moviesRepository.SaveChangesAsync();
}
public ActionResult Edit(int id, MovieCreateModel movieModel)
{
if (!ModelState.IsValid)
{
return(PartialView(movieModel));
}
Movie modelToSave = this.data.Movies.Find(id);
movieModel.TransferValuesTo(modelToSave);
var entry = this.data.Entry(modelToSave);
if (entry.State == EntityState.Detached)
{
this.dbSet.Attach(modelToSave);
}
entry.State = EntityState.Modified;
this.data.SaveChanges();
MovieViewModel viewmodel = MovieViewModel.MapToView(modelToSave);
return(this.PartialView("Details", viewmodel));
}
public async Task <IActionResult> Create([Bind("Id,Title,ReleaseDate,Genre,Price,Rating,Image")] MovieCreateModel movie)
{
if (ModelState.IsValid)
{
string uniqueFileName = null;
if (movie.Image != null)
{
// ;
string uploadsFolder = Path.Combine(hostingEnvironment.WebRootPath, "img");
uniqueFileName = Guid.NewGuid().ToString() + "_" + 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,
Genre = movie.Genre,
Price = movie.Price,
Rating = movie.Rating,
Image = uniqueFileName
};
_context.Add(newMovie);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(movie));
}
// GET: Movies/Edit/5
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(HttpNotFound());
}
Movie movie = await db.Movies.FindAsync(id);
if (movie == null)
{
return(HttpNotFound());
}
if (movie.UserId != User.Identity.GetUserId())
{
return(HttpNotFound());
}
var model = new MovieCreateModel
{
Name = movie.Name,
Description = movie.Description,
Year = movie.Year,
Director = movie.Director
};
return(View(model));
}
public async Task <ActionResult> Create(MovieCreateModel model)
{
if (ModelState.IsValid)
{
var movie = new Movie
{
Name = model.Name,
Description = model.Description,
Year = model.Year,
Director = model.Director,
UserId = User.Identity.GetUserId()
};
if (model.Poster != null)
{
if (model.Poster.ContentType == "image/jpeg" || model.Poster.ContentType == "image/bmp")
{
string fileName = System.IO.Path.GetFileName(model.Poster.FileName);
model.Poster.SaveAs(Server.MapPath("~/Posters/" + model.Name + "_" + fileName));
movie.PosterURL = "/Posters/" + model.Name + "_" + fileName;
}
}
db.Movies.Add(movie);
await db.SaveChangesAsync();
return(RedirectToAction("Details", new { id = movie.Id }));
}
return(View(model));
}
// GET: Movies/Create
public ActionResult Create()
{
var movie = new MovieCreateModel();
movie.Year = DateTime.Now.Year;
return(View(movie));
}
public IActionResult Create()
{
var genres = this.moviesService.GetAllGenres <GenreViewModel>();
var viewModel = new MovieCreateModel
{
Genres = genres,
};
return(this.View(viewModel));
}
public static Movie ConvertFromCreateModel(MovieCreateModel createMovie)
{
return(new Movie
{
Title = createMovie.Title,
Description = createMovie.Description,
ImageUrl = createMovie.ImageUrl,
Cast = createMovie.Cast,
Genre = createMovie.Genre
});
}
public IActionResult Create()
{
var movieTypes = _moviesTypesService.GetAll();
var viewModels = movieTypes.Select(x => x.ToMovieTypeModel()).ToList();
var viewModel = new MovieCreateModel();
viewModel.MovieTypes = viewModels;
return(View(viewModel));
}
public static Movie ToModel(this MovieCreateModel viewModel)
{
return(new Movie
{
Title = viewModel.Title,
ImgUrl = viewModel.ImgUrl,
Stars = viewModel.Stars,
Storyline = viewModel.Storyline,
Genre = viewModel.Genre,
MovieTypeId = viewModel.MovieTypeId
});
}
public static Movie CreateModelToMovieConvert(MovieCreateModel movieCreateModel)
{
return(new Movie
{
Title = movieCreateModel.Title,
ImageUrl = movieCreateModel.ImageUrl,
Description = movieCreateModel.Description,
Genre = movieCreateModel.Genre,
Cast = movieCreateModel.Cast,
YearReleased = movieCreateModel.YearReleased,
});
}
public IActionResult Create(MovieCreateModel createMovie)
{
if (ModelState.IsValid)
{
var movie = ModelConvertor.ConvertFromCreateModel(createMovie);
MoviesService.CreateMovie(movie);
return(RedirectToAction("ModifyOverview"));
}
else
{
return(View(createMovie));
}
}
public async Task <IActionResult> Create(MovieCreateModel input)
{
var movie = AutoMapperConfig.MapperInstance.Map <Movie>(input);
if (!this.ModelState.IsValid)
{
return(this.View(input));
}
await this.moviesService.Create(input);
return(this.RedirectToAction(nameof(this.MovieView), new { title = input.Title }));
}
public IActionResult Create(MovieCreateModel model)
{
if (ModelState.IsValid)
{
Movie movie = ModelConverter.CreateModelToMovieConvert(model);
MovieService.Add(movie);
return(RedirectToAction("Overview"));
}
else
{
return(View(model));
}
}
public async Task Create_WithInvalidInput_ShouldThrowException()
{
var dbContext = ApplicationDbContextCreatorInMemory.InitializeContext();
await this.SeedData(dbContext);
var moviesRepository = new EfDeletableEntityRepository <Movie>(dbContext);
var genresRepository = new EfDeletableEntityRepository <Genre>(dbContext);
var service = new MoviesService(moviesRepository, genresRepository);
var input = new MovieCreateModel()
{
};
await Assert.ThrowsAsync <ArgumentNullException>(() => service.Create(input));
}
// GET: Movies/Edit/5
public ActionResult Edit(int id)
{
Movie model =
this
.data
.Movies
.FirstOrDefault(m => m.Id == id);
if (model == null)
{
return(this.PartialView("NotFound"));
}
MovieCreateModel editModel = MovieCreateModel.MapToCreateModel(model);
return(this.PartialView("Edit", editModel));
}
public ActionResult Create(MovieCreateModel movieModel)
{
if (!ModelState.IsValid)
{
return(View(movieModel));
}
Movie saveModel = new Movie();
movieModel.TransferValuesTo(saveModel);
this.data.Movies.Add(saveModel);
this.data.SaveChanges();
MovieViewModel viewModel = MovieViewModel.MapToView(saveModel);
return(this.PartialView("Details", viewModel));
//return RedirectToAction("Details", new { id = saveModel.Id });
}
public IActionResult Create(MovieCreateModel movie)
{
if (ModelState.IsValid)
{
var domainModel = movie.ToModel();
_moviesService.CreateMovie(domainModel);
var userId = User.FindFirst("Id");
var logData = new LogData()
{
Type = LogType.Info, DateCreated = DateTime.Now, Message = $"User with id {userId} created movie {movie.Title}"
};
_logService.Log(logData);
return(RedirectToAction("ManageMovies", new { SuccessMessage = "Movie added sucessfully" }));
}
return(View(movie));
}
public IActionResult Create(MovieCreateModel newMovie)
{
/*ViewData["Movies"] = "Movies";*/
if (ModelState.IsValid)
{
FakeDatabase.Movies.Add(new Movie {
Id = FakeDatabase.Movies.Count + 1,
Title = newMovie.Title,
Genre = newMovie.Genre,
ReleaseYear = newMovie.ReleaseYear,
Runtime = newMovie.Runtime,
Image = "",
Rating = 0,
});
return(RedirectToAction("Index"));
}
return(View());
}
public async Task <IActionResult> Create([FromForm] MovieCreateModel MovieModel)
{
var picName = saveFile(MovieModel.Picture);
var videoName = saveFile(MovieModel.video);
var movie = new Movie {
Id = Guid.NewGuid().ToString(),
Title = MovieModel.Title,
Description = MovieModel.Description,
Picture = picName,
MovieLink = videoName,
CategoryId = MovieModel.CategoryId,
Actors = await getActors(MovieModel.actorsId)
};
await _movieRepo.Add(movie);
return(Ok());
}
public async Task <ActionResult> Edit(Int32?id, MovieCreateModel model)
{
if (id == null)
{
return(HttpNotFound());
}
Movie movie = await db.Movies.FindAsync(id);
if (movie == null)
{
return(HttpNotFound());
}
if (movie.UserId != User.Identity.GetUserId())
{
return(HttpNotFound());
}
if (ModelState.IsValid)
{
movie.Name = model.Name;
movie.Description = model.Description;
movie.Year = model.Year;
movie.Director = model.Director;
if (model.Poster != null)
{
string fileName = System.IO.Path.GetFileName(model.Poster.FileName);
model.Poster.SaveAs(Server.MapPath("~/Posters/" + model.Name + "_" + fileName));
movie.PosterURL = "/Posters/" + model.Name + "_" + fileName;
}
db.Entry(movie).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Details", new { id = movie.Id }));
}
return(View(movie));
}
public async Task Create_WithValidInput_ShouldReturnValidResult()
{
var dbContext = ApplicationDbContextCreatorInMemory.InitializeContext();
await this.SeedData(dbContext);
var moviesRepository = new EfDeletableEntityRepository <Movie>(dbContext);
var genresRepository = new EfDeletableEntityRepository <Genre>(dbContext);
var service = new MoviesService(moviesRepository, genresRepository);
var input = new MovieCreateModel()
{
Title = "Titanic",
Country = "USA",
GenreId = 1,
};
var movie = service.Create(input);
var result = service.GetByTitle <MovieViewModel>("Titanic");
Assert.Equal("USA", result.Country);
}
public IActionResult Create()
{
var movie = new MovieCreateModel();
return(View(movie));
}
public IActionResult Create()
{
MovieCreateModel model = new MovieCreateModel();
return(View(model));
}
