public void CreateAsync_CallsService_Always()
{
var viewModel = GetModifyGenreViewModel();
_apiGenreController.CreateAsync(viewModel);
A.CallTo(() => _genreService.CreateAsync(A <GenreDto> ._)).MustHaveHappenedOnceExactly();
}
public async Task <IActionResult> PostAsync(CreateGenreRequest request, CancellationToken cancellationToken)
{
_logger.LogInformation("Genre/Post was requested.");
var response = await _genreService.CreateAsync(_mapper.Map <GenreDto>(request));
return(Ok(_mapper.Map <GenreResponse>(response)));
}
public async Task <IActionResult> CreateAsync(
[Bind(Prefix = nameof(ModifyGenreViewModel))]
ModifyGenreViewModel modifyGenreViewModel)
{
if (!ModelState.IsValid)
{
var viewModel = await _genreViewModelFactory.CreateAsync(modifyGenreViewModel);
return(View("Create", viewModel));
}
var dto = _mapper.Map <GenreDto>(modifyGenreViewModel);
try
{
await _genreServices.CreateAsync(dto);
}
catch (EntityExistsWithKeyValueException <Genre> e)
{
const string prefix = nameof(ModifyGenreViewModel);
ModelState.AddModelError($"{prefix}.{e.Key}", e.Message);
var viewModel = await _genreViewModelFactory.CreateAsync(modifyGenreViewModel);
_logger.LogWarning(e.Message);
return(View("Create", viewModel));
}
_logger.LogDebug($"Create new genre with name {modifyGenreViewModel.Name}");
return(RedirectToAction(nameof(GetAllAsync)));
}
public void CreateAsync_ReturnsView_WhenCatchException()
{
var viewModel = CreateModifyGenreViewModel();
const string key = nameof(viewModel.Name);
var value = viewModel.Name;
A.CallTo(() => _genreService.CreateAsync(A <GenreDto> ._))
.Throws(new EntityExistsWithKeyValueException <Genre>(key, value));
var result = _genreController.CreateAsync(viewModel).Result;
result.Should().BeViewResult();
}
public async Task <IActionResult> Create([Bind("Name")] Genre genre)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
Genre newGenre = await genreService.CreateAsync(genre);
if (newGenre == null)
{
return(BadRequest());
}
return(CreatedAtRoute("FindGenreById", new { id = newGenre.Id }, newGenre));
}
private async Task CreateGenresAsync(Movie movie)
{
foreach (var genre in movie.Genres)
{
var existingGenre = await _genreService.GetByNameAsync(genre.Name);
if (existingGenre == null)
{
existingGenre = await _genreService.CreateAsync(genre);
}
genre.Id = existingGenre.Id;
await CreateMovieGenreAsync(new MovieGenre
{
MovieId = movie.Id,
GenreId = genre.Id
});
}
}
public async Task <HttpResponseMessage> Add([FromBody] GenreCreateModel model)
{
HttpResponseMessage returnMessage = new HttpResponseMessage();
var role = mapper.Map <GenreDto>(model);
var result = await service.CreateAsync(role);
if (result.IsSuccess)
{
string message = ($"Student Created - {result.Entity.Id}");
returnMessage = new HttpResponseMessage(HttpStatusCode.Created);
returnMessage.RequestMessage = new HttpRequestMessage(HttpMethod.Post, message);
}
else
{
returnMessage = new HttpResponseMessage(HttpStatusCode.ExpectationFailed);
returnMessage.RequestMessage = new HttpRequestMessage(HttpMethod.Post, result.GetErrorString());
}
return(returnMessage);
}
public async Task <IActionResult> CreateAsync(ModifyGenreViewModel modifyGenreViewModel)
{
modifyGenreViewModel.Id = Guid.NewGuid().ToString();
var dto = _mapper.Map <GenreDto>(modifyGenreViewModel);
try
{
await _genreService.CreateAsync(dto);
}
catch (ValidationException <Genre> e)
{
const string prefix = nameof(ModifyGenreViewModel);
ModelState.AddModelError($"{prefix}.{e.Key}", e.Message);
_logger.LogWarning(e.Message);
return(BadRequest(ModelState));
}
_logger.LogDebug($"Create new genre with name {modifyGenreViewModel.Name}");
return(CreatedAtAction(nameof(GetByIdAsync), new { id = modifyGenreViewModel.Id }, modifyGenreViewModel));
}
public async Task <ResultResponse> Add([FromBody] GenreDto dto)
{
return(await _service.CreateAsync(dto));
}
