public void DadoInfoValidasDeveRetornarCreatedResult()
{
//Arrange
FilmeDTO filmeDTO = new FilmeDTO()
{
Titulo = "Velozes e Furiosos",
Descricao = "Velozes e Furiosos",
AnoLancamento = "2009",
IdIdiomaDublagem = 7
};
var filmeController = new FilmeController(_repositorio, _mapper);
_urlHelper.Setup(
x => x.Action(It.IsAny <UrlActionContext>())
).Returns("test");
filmeController.Url = _urlHelper.Object;
//Act
var retorno = filmeController.Cadastrar(filmeDTO);
//Assert
Assert.IsType <CreatedResult>(retorno);
}
public async Task <ActionResult <FilmeDTO> > PutFilme([FromRoute] int id, [FromBody] FilmeDTO filmeDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != filmeDto.FilmeId)
{
return(BadRequest());
}
try {
var filme = _mapper.Map <Filme>(filmeDto);
_repo.Update(filme);
var save = await _repo.SaveAsync(filme);
} catch (Exception) {
if (!FilmesExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok());
}
public async Task <bool> UpdateAsync(string Id, FilmeDTO filmeDto)
{
var currentFilme = await filmeRepository.GetFilmeAsync(Id);
currentFilme.MapToNewValues(filmeDto);
return(await filmeRepository.UpdateFilmeAsync(Id, currentFilme));
}
public async Task <FilmeDTO> CreateAsync(FilmeDTO filmeDto)
{
var filme = filmeDto.MapToModel();
await filmeRepository.AddFilmeAsync(filme);
return(filme.MapToDto());
}
public static Filme MapToNewValues(this Filme currentValue, FilmeDTO newValue)
{
currentValue.Titulo = currentValue.Titulo;
currentValue.Lancamento = currentValue.Lancamento;
currentValue.QtDiasExibicao = currentValue.QtDiasExibicao;
currentValue.Descricao = currentValue.Descricao;
currentValue.Genero = currentValue.Genero;
currentValue.Diretor = currentValue.Diretor;
currentValue.Atores = MapAtoresToModel(newValue.Atores);
return(currentValue);
}
public async Task <ActionResult> PutAsync(string id, [FromBody] FilmeDTO filmeToUpdate)
{
var filme = await filmeService.GetFilmeByIdAsync(id);
if (filme == null)
{
return(NotFound());
}
await filmeService.UpdateAsync(id, filmeToUpdate);
return(NoContent());
}
public static Filme MapToModel(this FilmeDTO filme)
{
var f = new Filme
{
Titulo = filme.Titulo,
Lancamento = filme.Lancamento,
QtDiasExibicao = filme.QtDiasExibicao,
Descricao = filme.Descricao,
Genero = filme.Genero,
Diretor = filme.Diretor,
Atores = MapAtoresToModel(filme.Atores),
};
return(f);
}
public async Task <ActionResult <FilmeDTO> > PostFilme([FromBody] FilmeDTO filmeDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var filme = _mapper.Map <Filme>(filmeDto);
_repo.Add(filme);
var save = await _repo.SaveAsync(filme);
var filmeDTO = _mapper.Map <FilmeDTO>(filme);
return(CreatedAtAction("GetFilme", new { id = filmeDTO.FilmeId }, filmeDTO));
}
public IActionResult Atualizar([FromBody] FilmeDTO filmeDTO)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResponse.FromModelState(ModelState)));
}
Filme filme = _mapper.Map <Filme>(filmeDTO);
_repositorio.Atualizar(filme);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ErrorResponse.From(ex)));
}
}
public async Task <FilmeDTO> BuscarFilme(int codigo)
{
var model = await _filmeRepository.BuscarFilme(codigo);
if (model == null)
{
return(null);
}
var dto = new FilmeDTO
{
Nome = model.Nome,
Codigo = model.Codigo,
Duracao = model.Duracao,
FaixaEtaria = model.FaixaEtaria,
Genero = model.Genero
};
return(dto);
}
public async Task <ActionResult <ResponseDTO> > ClienteDevolverFilme(int idCliente, [FromBody] FilmeDTO reqFilmeDTO)
{
try
{
FilmeDTO resFilmeDTO = await iLocacaoService.ClienteDevolverFilme(idCliente, reqFilmeDTO);
if (resFilmeDTO != null)
{
return(Ok(new ResponseDTO(StatusCodes.Status200OK, "OK", resFilmeDTO)));
}
else
{
return(BadRequest(new ResponseDTO(StatusCodes.Status400BadRequest, "Filme com atraso na devolução", reqFilmeDTO)));
}
}
catch (Exception ex)
{
iLogger.LogError(ex.Message);
return(BadRequest(new ResponseDTO(StatusCodes.Status500InternalServerError, "Error", null)));
}
}
public async Task <ActionResult <ResponseDTO> > ValidarEstoqueFilme(int id)
{
try
{
FilmeDTO filmeDTO = await iLocacaoService.VeriricarEstoqueFilme(id);
if (filmeDTO != null)
{
return(Ok(new ResponseDTO(StatusCodes.Status200OK, "OK", filmeDTO)));
}
else
{
return(BadRequest(new ResponseDTO(StatusCodes.Status400BadRequest, "Filme indisponível no estoque", id)));
}
}
catch (Exception ex)
{
iLogger.LogError(ex.Message);
return(BadRequest(new ResponseDTO(StatusCodes.Status500InternalServerError, "Error", null)));
}
}
public void PassadoNovasInformacoesFilmeDeveSerAtualizado()
{
//Arrange
var repositorio = mockRepositorio.Object;
var filmeController = new FilmeController(repositorio, _mapper);
FilmeDTO filmeDTO = new FilmeDTO()
{
Id = 2,
Titulo = "Carros 2",
Descricao = "Carros",
IdIdiomaDublagem = 7,
AnoLancamento = "2009"
};
//Act
var retorno = filmeController.Atualizar(filmeDTO);
//Assert
Assert.IsType <OkResult>(retorno);
}
public async Task <List <FilmeDTO> > BuscarFilmes()
{
var models = await _filmeRepository.BuscarFilmes();
var dtos = new List <FilmeDTO>();
foreach (var model in models)
{
var dto = new FilmeDTO
{
Nome = model.Nome,
Codigo = model.Codigo,
Duracao = model.Duracao,
FaixaEtaria = model.FaixaEtaria,
Genero = model.Genero
};
dtos.Add(dto);
}
return(dtos);
}
public IActionResult Cadastrar([FromBody] FilmeDTO filmeDTO)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResponse.FromModelState(ModelState)));
}
Filme filme = _mapper.Map <Filme>(filmeDTO);
_repositorio.Incluir(filme);
var uri = Url.Action("ObterPorId", new { filme.Id });
filmeDTO.Id = filme.Id;
return(Created(uri, filmeDTO));
}
catch (Exception ex)
{
return(BadRequest(ErrorResponse.From(ex)));
}
}
public async Task <ActionResult <FilmeDTO> > PostAsync([FromBody] FilmeDTO filme)
{
var createdFilme = await filmeService.CreateAsync(filme);
return(CreatedAtRoute("GetFilme", new { createdFilme.Id }, createdFilme));
}