public async void Atualizar_Livro_DeveRetornarBadRequest()
        {
            _baseResponse.StatusCode = StatusCodes.Status400BadRequest;
            _requestLivro.Titulo     = "";
            _mapper.Map <Livro>(_requestLivro).Returns(_livro);
            await _repository.Atualizar(_livro);

            var resultado = await _service.Inserir(_requestLivro);

            resultado.StatusCode.Should().Be(StatusCodes.Status400BadRequest);
        }
Beispiel #2
0
        public async Task Atualizar(Guid id, LivroInputModel livro)
        {
            var entidadeLivro = await _livroRepository.Obter(id);

            if (entidadeLivro == null)
            {
                throw new LivroNaoCadastradoException();
            }

            entidadeLivro.NomeAutor = livro.NomeAutor;
            entidadeLivro.Titulo    = livro.Titulo;
            entidadeLivro.Descricao = livro.Descricao;
            entidadeLivro.Preco     = livro.Preco;

            await _livroRepository.Atualizar(entidadeLivro);
        }
        public Task Handle(AtualizarLivroCommand request, CancellationToken cancellationToken)
        {
            var livroAtual = _livroRepository.ObterPorId(request.Id);

            if (!LivroExistente(request.Id, request.MessageType))
            {
                return(Task.CompletedTask);
            }

            var livro = new Livro(request.Isbn, request.Autor, request.Nome, request.Valor, request.DataPublicacao, request.ImgCapa);

            if (IsbnExistente(livro.Isbn, request.MessageType))
            {
                NotificarValidacoesErro(livro.ValidationResult);
                return(Task.CompletedTask);
            }

            _livroRepository.Atualizar(livro);

            if (Commit())
            {
                _mediator.PublicarEvento(new LivroAtualizadoEvent(request.Id, request.Isbn, request.Autor, request.Nome, request.Valor, request.DataPublicacao, request.ImgCapa));
            }

            return(Task.CompletedTask);
        }
Beispiel #4
0
        public LivroViewModel Atualizar(LivroViewModel livro)
        {
            var model = _mapper.Map <LivroViewModel, Livro>(livro);

            model = _repository.Atualizar(model);
            _repository.SaveChanges();
            return(_mapper.Map <Livro, LivroViewModel>(model));
        }
Beispiel #5
0
 public Livro Atualizar(Livro livro)
 {
     if (livro.Id < 1)
     {
         throw new IdentificadorIndefinidoException();
     }
     livro.Validar();
     return(_repository.Atualizar(livro));
 }
Beispiel #6
0
        public async Task Atualizar(Livro livro)
        {
            if (!ExecutarValidacao(new LivroValidation(), livro))
            {
                return;
            }

            await _livroRepository.Atualizar(livro);
        }
 public void Put([FromBody] LivroViewModel livroViewModel)
 {
     if (ModelState.IsValid)
     {
         if (VerificarNaoDuplicidade(livroViewModel.ISBN))
         {
             _livroRepository.Atualizar(LivroAdapter.ToDomainModel(livroViewModel));
         }
     }
 }
Beispiel #8
0
        public async Task Executar(int id, Livro livro)
        {
            try
            {
                var dadoDoLivro = await _livroRepository.BuscarPorId(id);

                dadoDoLivro.AtualizarDadosDoLivro(livro.Nome, livro.Editora);

                await _livroRepository.Atualizar(dadoDoLivro);
            }
            catch (System.Exception)
            {
                this.Erros.Add("Erro", "Ocorreu um erro ao alterar um livro.");
            }
        }
Beispiel #9
0
        public async Task <BaseResponse> Atualizar(RequestLivro request)
        {
            try
            {
                _logger.LogInformation("Iniciando atualização do livro.");

                var valid = await ValidarRequest(new LivroValidator(), request);

                if (valid != null)
                {
                    return(valid);
                }


                if (await _livroRepository.LivroCadastrado(request.Id))
                {
                    var entity = await _livroRepository.ObterPorId(request.Id);

                    var livro = _mapper.Map <Livro>(request);
                    livro.DataAlteracao = DateTime.Now;
                    livro.DataCadastro  = entity.DataCadastro;

                    var response = await ObterStatusCode(
                        "Livro atualizado com sucesso.",
                        StatusCodes.Status200OK,
                        _mapper.Map <ResponseLivro>(await _livroRepository.Atualizar(livro)));

                    _logger.LogInformation("Fim da atualização do livro.");

                    return(response);
                }
                else
                {
                    return(await ObterStatusCode("Livro informado não localizado.", StatusCodes.Status400BadRequest));
                }
            }
            catch (Exception ex)
            {
                return(await ObterStatusCode("Erro ao atualizar o livro", StatusCodes.Status400BadRequest, null, ex));
            }
        }
Beispiel #10
0
        public ActionResult Edit(Livro livro)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    livroRepository.Atualizar(livro);
                    livroRepository.Salvar();

                    return(RedirectToAction("Listar"));
                }

                ViewBag.AutoresEditar    = retornaSelectListItemRepository.Autores();
                ViewBag.CategoriasEditar = retornaSelectListItemRepository.Categorias();

                return(View(livro));
            }
            catch
            {
                return(View());
            }
        }
Beispiel #11
0
 public Livro Atualizar(Livro entity)
 {
     return(_livroRepository.Atualizar(entity));
 }
Beispiel #12
0
 public async Task Atualizar(Livro livro)
 {
     _livroRepository.Atualizar(livro);
     await _livroRepository.Commit();
 }
 public Livro Atualizar(Livro obj)
 {
     return(_livroRepository.Atualizar(obj));
 }