public async Task <ActionResult> Post(CreateMovieRequest model) { Guid movieId = Guid.NewGuid(); await _movieService.Add(movieId, model); return(CreatedAtRoute(nameof(GetMovieById), new { id = movieId }, movieId)); }
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)); }
public async Task <BaseResponseDto <bool> > Handle(CreateMovieRequest request, CancellationToken cancellationToken) { BaseResponseDto <bool> response = new BaseResponseDto <bool>(); try { var movie = new Movie { Name = request.Name, Rating = request.Rating, IsDeleted = false, CreatedAt = DateTime.Now }; await _repository.CreateAsync(movie); response.Data = true; await _mediator.Publish(new NewMovieCreatedEvent(movieName : movie.Name)); } catch (Exception ex) { _logger.LogError(ex, ex.Message); response.Errors.Add("An error occurred while creating the movie."); } return(response); }
public async Task <BaseResponseDto <bool> > Handle(CreateMovieRequest request, CancellationToken cancellationToken) { BaseResponseDto <bool> response = new(); try { var movie = new Movie { Name = request.Name, Rating = request.Rating, AgeGroup = request.AgeGroup, IsDeleted = false, CreatedAt = DateTime.Now }; await _repository.CreateAsync(movie); response.Data = true; } catch (Exception ex) { _logger.LogError(ex, ex.Message); response.Errors.Add("An Error occured while creating movie."); } return(response); }
public async Task Add(Guid movieId, CreateMovieRequest request) { Movie movie = MovieFactory.Create(movieId, request.Title); _ctx.Add(movie); await _ctx.SaveChangesAsync(); }
public async Task <IActionResult> CreateMovie(CreateMovieRequest request) { if (ModelState.IsValid) { string url = ""; if (request.File == null) { url = "https://localhost:44304/img/movie.jpg"; } else { url = await ImageHandler.UploadImage(request.File); } var movie = new Movie { DateUpload = DateTime.Now, Description = request.Description, Director = request.Director, URL = url, Name = request.Name, MovieTypeId = request.MovieTypeId, MovieId = Guid.NewGuid().ToString() }; AdministrationRepository.AddMovie(movie); return(RedirectToAction("GetMovies")); } foreach (var error in ModelState.Values) { foreach (var item in error.Errors) { Logger.LogError(item.ErrorMessage); } } return(View("GetMovies")); }
public async Task <IActionResult> CreateAsync(CreateMovieRequest request, CancellationToken token) { _logger.LogInformation("POST /Movie request accepted"); var response = await _movieService.CreateAsync(_mapper.Map <MovieDTO>(request)); return(Ok(_mapper.Map <MovieResponse>(response))); }
public async Task <Movie> CreateMovieAsync(String token, CreateMovieRequest movie) { httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token); MoviesControllerClient _movieClient = new MoviesControllerClient(httpClient); var a = await _movieClient.CreateMovieAsync(movie); return(a); }
public async Task <IActionResult> CreateMovie(CreateMovieRequest movie, TimeSpan movieLength) { movie.Length = Convert.ToInt64(movieLength.TotalMinutes); await movieFacade.CreateMovieAsync(HttpContext.User.FindFirst(ClaimTypes.Hash).Value, movie); return(RedirectToAction(nameof(List))); }
public Movie CreateMovie(CreateMovieRequest request) { var names = request.MovieNames?.ToDictionary(o => o.Lang, o => o.Name); var entity = MoviesRepository.CreateMovie(request.OriginalName, request.TitleImageUrl, request.Country, request.Length, request.Description, request.CreatedYear.Value, names, request.Actors, request.Directors, request.GenreIds); return(Mapper.Map <Movie>(entity)); }
public async Task <ActionResult <GetMovieByIdResponse> > CreateMovie([FromBody] CreateMovieRequest createMovieRequest) { try { var response = await _mediator.Send(createMovieRequest); return(Created($"api/movies/{response.Id}", response)); } catch (InvalidRatingException) { return(BadRequest()); } }
public async Task GivenMovieIsDefined(string movie) { CreateMovieRequest request = new CreateMovieRequest() { Title = movie }; HttpResponseMessage response = await Client.PostAsJsonAsync("/api/movies/", request); _createdMovieId = GetGuidFromLocationHeader(response); }
public void Should_create_movie_and_use_existing_genre_if_genre_exists( IWebApiMovieRestContext context, CreateMovieRequestHandler createMovieRequestHandler, Genre alreadyExistingGenre, Movie newMovie, CreateMovieRequest createMovieRequest, MoviesResponse moviesResponse, Movie createdMovie ) { "Given a WebApiMovieRestContext" .Given(() => context = new WebApiMovieRestContext().AutoRollback()); "And a CreateMovieRequestHandler constructed with the context" .And(() => createMovieRequestHandler = new CreateMovieRequestHandler(context)); "And a Genre that already exists in the database".And(() => { var alreadyExistingGenreName = new WebApiMovieRestInitializer() .SeedMovies().First() .Genres.First() .Name; alreadyExistingGenre = Db.GetGenreByName(alreadyExistingGenreName); }); "And a CreateMovieRequest containing a genre that exists in the database". And(() => createMovieRequest = new CreateMovieRequestBuilder().WithGenres(new[] { alreadyExistingGenre.Name })); "After handling the CreateMovieRequest" .When(() => moviesResponse = createMovieRequestHandler.Handle(createMovieRequest)); "And commiting the WebApiMovieRestContext" .When(() => context.Commit()); "Then a Movie should have be created in the database".Then(() => { var createdMovieId = moviesResponse.Movies.First().Id; createdMovie = Db.GetMovieById(createdMovieId); createdMovie.Should().NotBeNull(); }); "And the already existing Genre should have be used".Then(() => createdMovie.Genres.Single().ShouldBeEquivalentTo(alreadyExistingGenre)); "And the new movie should have the same values as the request" .Then(() => createdMovie.ShouldBeEquivalentTo(createMovieRequest, o => o.ExcludingMissingProperties())); "And the new movie should have the same genre as the request" .Then(() => createdMovie.Genres.Single().Name.Should().Be(createMovieRequest.Genres[0])); "And the MovieResponse should be the newly created Movie translated" .Then(() => moviesResponse.ShouldBeEquivalentTo(createdMovie.Yield().ToResponse())); }
public async Task <IActionResult> Post([FromBody] CreateMovieRequest movie) { var userId = int.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier)); var newMovie = new Movie(movie.Title, movie.Description, movie.PublicationDate, userId); _dbContext.Movies.Add(newMovie); await _dbContext.SaveChangesAsync(); return(CreatedAtAction(nameof(Get), new { id = newMovie.Id }, movie)); }
public async Task <ActionResult <string> > CreateMovieAsync([FromBody] CreateMovieRequest createMovieRequest) { BaseResponseDto <bool> createResponse = await _mediator.Send(createMovieRequest); if (createResponse.Data) { return(Created("...", null)); } else { return(BadRequest(createResponse.Errors)); } }
public async Task <CreateMovieResponse> Add(CreateMovieRequest request) { var movie = request.ProjectedAs <Movie>(); var response = _service.Add(movie); if (response.IsSuccess) { _uow.Commit(); } await Task.Delay(1); return(movie.ProjectedAs <CreateMovieResponse>()); }
public async Task <ActionResult> CreateNewMovie([FromBody] CreateMovieRequest request) { var createdMovie = mapper.Map <Movie>(request); var result = await movieService.CreateNewMovie(createdMovie); if (result == false) { return(BadRequest()); } var locationUri = uriService.GetMovieUri(createdMovie.Id); var response = mapper.Map <MovieResponse>(createdMovie); return(Created(locationUri, response)); }
public void CreateMovieNullFileTest() { CreateMovieRequest request = new CreateMovieRequest() { MovieTypeId = Guid.NewGuid().ToString(), Description = "Its a fake description", Director = "Fake Director", File = null, Name = "Fake Name" }; Task <IActionResult> createMovie = administration.CreateMovie(request); Assert.IsType <RedirectToActionResult>(createMovie.Result); }
public IHttpActionResult Add(CreateMovieRequest req) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } Movie m = new Movie { Title = req.Title, Rating = req.Rating }; MovieRepoStub.Create(m); return(Created($"movies/get/{m.Id}", m)); }
public async Task CreateMovieTest_ResponseStatus_400(CreateMovieRequest request) { // Arrange var mockMovieService = new Mock <IMovieService>(); mockMovieService.Setup(x => x.CreateAsync(It.IsAny <MovieEntity>())).Throws <EntityAlreadyExistException>(); // Act var movieController = new MovieController(Mapper, mockMovieService.Object); MockModelState(request, movieController); var response = await movieController.CreateMovie(request); // Assert var badRequestObject = Assert.IsType <BadRequestObjectResult>(response.Result); Assert.IsType <SerializableError>(badRequestObject.Value); }
public async Task CreateMovieTest_ResponseStatus_409(CreateMovieRequest request) { // Arrange var mockMovieService = new Mock <IMovieService>(); mockMovieService.Setup(x => x.CreateAsync(It.IsAny <MovieEntity>())).Throws <EntityAlreadyExistException>(); // Act var movieController = new MovieController(Mapper, mockMovieService.Object); MockModelState(request, movieController); var response = await movieController.CreateMovie(request); // Assert var conflictObject = Assert.IsType <ConflictObjectResult>(response.Result); Assert.IsType <string>(conflictObject.Value); Assert.Equal("Movie with same meta data already exists", conflictObject.Value); }
public IActionResult AddNewMovie() { var detailsDecode = JObject.Parse(Request.Form["movieDetails"]); string filmName = detailsDecode["name"].ToString(); string filmDescription = detailsDecode["description"].ToString(); int filmDuration = Int32.Parse(detailsDecode["duration"].ToString()); if (movieRepository.FindByName(filmName)) { return(Conflict("Movie is existing in database!")); } else { var file = Request.Form.Files[0]; var folderName = Path.Combine("Resources", "Img"); var pathToSave = Path.Combine(Directory.GetCurrentDirectory(), folderName); if (file.Length > 0) { var fullPath = Path.Combine(pathToSave, file.FileName); var dbPath = Path.Combine(folderName, file.FileName); using (var stream = new FileStream(fullPath, FileMode.Create)){ file.CopyTo(stream); } var filmDetails = new CreateMovieRequest { Name = filmName, Description = filmDescription, Duration = filmDuration, MoviePoster = dbPath }; return(Ok(movieRepository.Create(filmDetails.returnMovie()))); } else { return(BadRequest()); } } }
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)); }
public async Task <IActionResult> Create([FromBody] CreateMovieRequest request) { var movie = _movieService.CreateMovieFromRequest(request); var success = await _movieService.AddMovieAsync(movie); if (!success) { return(NotFound()); } var baseUrl = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.ToUriComponent()}"; var locationUri = baseUrl + "/" + ApiRoutes.Movies.Get.Replace("{Id}", movie.MovieGuid.ToString()); var response = new MovieResponse { MovieId = movie.MovieGuid, Title = movie.Title }; return(Created(locationUri, response)); }
public async Task <ActionResult <MovieViewModel> > Post([FromBody] CreateMovieViewModel viewModel) { var request = new CreateMovieRequest { Movie = viewModel }; // validate request model await _createMovieRequestValidator.ValidateAsync(request); // map view model to domain model var movie = _mapper.Map <MovieDomainModel>(viewModel); // create new movie var createdMovie = await _movieService.CreateMovieAsync(movie); // prepare response var response = _mapper.Map <MovieViewModel>(createdMovie); // 201 response return(HandleCreatedResponse(response)); }
public async Task <ActionResult> Create([FromBody] CreateMovieRequest request) { try { if (!ModelState.IsValid) { return(BadRequest(ModelState.GetErrorResponse())); } var response = await _service.Add(request); if (!response.Success) { return(BadRequest(response.Erros)); } return(Ok()); } catch (Exception ex) { return(BadRequest(ex)); } }
public IActionResult CreateMovie([FromBody] CreateMovieRequest request) { var movie = Service.CreateMovie(request); return(Ok(movie)); }