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);
        }
Beispiel #2
0
        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());
        }
Beispiel #3
0
        public async Task <bool> UpdateAsync(string Id, FilmeDTO filmeDto)
        {
            var currentFilme = await filmeRepository.GetFilmeAsync(Id);

            currentFilme.MapToNewValues(filmeDto);

            return(await filmeRepository.UpdateFilmeAsync(Id, currentFilme));
        }
Beispiel #4
0
        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);
        }
Beispiel #8
0
        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));
        }
Beispiel #9
0
        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);
        }
Beispiel #11
0
        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)));
            }
        }
Beispiel #12
0
        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);
        }
Beispiel #15
0
        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));
        }