public async Task <IActionResult> Create(CreateMovieResponse movieResponseViewModel)
        {
            if (ModelState.IsValid)
            {
                Movie movie = new Movie();

                var movieInDb = _context.Movie.SingleOrDefault(m => m.Name.ToLower().Trim() == movieResponseViewModel.Name.ToLower().Trim());

                if (movieInDb != null)
                {
                    return(RedirectToAction("Details", new { id = movieInDb.Id }));
                }

                movie.Name         = movieResponseViewModel.Name;
                movie.GenreId      = movieResponseViewModel.GenreId;
                movie.Description  = movieResponseViewModel.Description;
                movie.ImgCode      = movieResponseViewModel.ImgCode;
                movie.Year         = movieResponseViewModel.Year;
                movie.MoviesActors = new List <MovieActor>();

                var director = _context.Director.FirstOrDefault(d => d.Name == movieResponseViewModel.Director.Name);

                if (director == null)
                {
                    movie.Director = new Director
                    {
                        Name = movieResponseViewModel.Director.Name
                    };
                }
                else
                {
                    movie.Director = director;
                }

                var actors = _context.Actor.Where(a => movieResponseViewModel.Actors.Contains(a.Name)).Select(a => a.Name).ToList();

                if (actors.Count > 0)
                {
                    if (actors.Count > 0)
                    {
                        foreach (var act in movieResponseViewModel.Actors)
                        {
                            //if (actors.Contains())
                            //{

                            //}
                        }
                    }
                }


                _context.Add(movie);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            return(View());
        }
示例#2
0
        public ActionResult <CreateMovieResponse> Post([FromBody] CreateMovieRequest request)
        {
            // validate request model
            _createMovieRequestValidator.Validate(request);

            // map view model to domain model
            var movie = _mapper.Map <MovieDomainModel>(request.Movie);

            // create new movie
            var createdMovie = _movieService.CreateMovie(movie);

            // prepare response
            var response = new CreateMovieResponse
            {
                Movie = _mapper.Map <MovieResponseViewModel>(createdMovie)
            };

            // 201 response
            return(HandleCreatedResponse(response));
        }
示例#3
0
        public async Task CreateMovieTest_ResponseStatus_200(CreateMovieRequest request, CreateMovieResponse expectedResult)
        {
            // Arrange
            var expectedMovieEntity = Mapper.Map <MovieEntity>(expectedResult);
            var mockMovieService    = new Mock <IMovieService>();

            mockMovieService.Setup(x => x.CreateAsync(It.IsAny <MovieEntity>()))
            .Returns(Task.FromResult(expectedMovieEntity));

            // Act
            var movieController = new MovieController(Mapper, mockMovieService.Object);

            MockModelState(request, movieController);
            var response = await movieController.CreateMovie(request);

            // Assert
            var okObjectResponse = Assert.IsType <OkObjectResult>(response.Result);
            var movieResponse    = Assert.IsType <CreateMovieResponse>(okObjectResponse.Value);

            Assert.Equal(expectedResult.Id, movieResponse.Id);
            Assert.Equal(expectedResult.Title, movieResponse.Title);
            Assert.Equal(expectedResult.PlotSummary, movieResponse.PlotSummary);
            Assert.Equal(expectedResult.Language, movieResponse.Language);
            Assert.Equal(expectedResult.ReleaseDate, movieResponse.ReleaseDate);
            Assert.Equal(expectedResult.Genre, movieResponse.Genre);
            Assert.Equal(expectedResult.Director, movieResponse.Director);
            Assert.True(expectedResult.CastAndCrew.SequenceEqual(movieResponse.CastAndCrew));
        }