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