public void ClienteService_Atualizar_ExecutarComSucesso()
{
// Arrange
var cliente = _clienteTestsFixture.GerarClienteValido();
_clienteTestsFixture.Mocker.GetMock <IClienteRepository>().Setup(p => p.ObterPorId(cliente.Id)).Returns(Task.FromResult(cliente));
_clienteTestsFixture.Mocker.GetMock <IClienteRepository>().Setup(p => p.Buscar(It.IsAny <Expression <Func <Cliente, bool> > >())).Returns(new List <Cliente>().AsQueryable());
// Act
_clienteService.Atualizar(cliente);
// Assert
_clienteTestsFixture.Mocker.GetMock <IMediatorHandler>().Verify(p => p.RaiseEvent(It.IsAny <ClienteAtualizadoEvent>(), It.IsAny <CancellationToken>()), Times.Once);
}
public IActionResult AtualizarCliente(Cliente cliente)
{
_clienteService.Atualizar(cliente);
_session.SetString("Alertas", "Parabéns!!!| Você acabou de atualizar um cliente.");
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Put(Guid id, ClienteViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var cliente = await _clienteRepository.ObterPorId(id);
if (cliente == null)
{
return(NotFound());
}
_mapper.Map(model, cliente);
if (await _clienteService.Atualizar(cliente))
{
return(Created("", _mapper.Map <ClienteViewModel>(cliente)));
}
}
catch (System.Exception ex)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, ex.Message));
}
return(BadRequest());
}
public ClienteViewModel Atualizar(ClienteViewModel clienteViewModel)
{
BeginTransaction();
_clienteService.Atualizar(Mapper.Map <ClienteViewModel, Cliente>(clienteViewModel));
Commit();
return(clienteViewModel);
}
public async Task <IActionResult> Edit(Guid id, ClienteViewModel clienteViewModel)
{
if (id != clienteViewModel.Id)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(View(clienteViewModel));
}
var cliente = _mapper.Map <Cliente>(clienteViewModel);
await _clienteService.Atualizar(cliente);
if (!OperacaoValida())
{
//Para retornar todas as informacoes de endereco novamente
return(View(await ObterClienteEndereco(id)));
}
TempData["Editado"] = "Cliente editado com sucesso!";
return(RedirectToAction(nameof(Index)));
}
private void ProcessarClientes(IEnumerable <ICliente> clientes)
{
try
{
_clienteService.BeginTransaction();
clientes.ToList().ForEach(cliente =>
{
if (_clienteService.ObterPorId(cliente.IdentificadorERP) == null)
{
_clienteService.Inserir(cliente);
}
else
{
_clienteService.Atualizar(cliente);
}
});
_clienteService.Commit();
}
catch (Exception)
{
_clienteService.Rollback();
throw;
}
}
public ClienteViewModel Atualizar(ClienteViewModel clienteViewModel)
{
//TODO: Faltou atualizar o endereço
var cliente = Mapper.Map <Cliente>(clienteViewModel);
cliente.DefinirComoAtivo();
if (!cliente.EhValido())
{
return(clienteViewModel);
}
var clienteReturn = _clienteService.Atualizar(cliente);
if (clienteReturn.ValidationResult.IsValid)
{
if (!SaveChanges())
{
AdicionarErroValidacao(clienteReturn.ValidationResult, "Ocorreu um erro ao salvar os dados no banco de dados");
}
}
clienteReturn.ValidationResult = clienteReturn.ValidationResult;
return(clienteViewModel);
}
public IActionResult PutCliente(Guid id, Cliente cliente)
{
if (id != cliente.Id)
{
return(BadRequest());
}
try
{
_clienteService.Atualizar(cliente);
}
catch (DbUpdateConcurrencyException)
{
if (!ClienteExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public ClienteCommand Atualizar(ClienteCommand clienteCommand)
{
var cliente = _clienteService.ObterPorId(clienteCommand.IdPessoa.Value);
cliente.AtualizarDados(clienteCommand.Nome, clienteCommand.CPF, clienteCommand.Celular,
clienteCommand.Email, clienteCommand.DataDeNascimento.Value);
var clienteRetorno = _clienteService.Atualizar(cliente);
var endereco = _enderecoService.ObterEnderecoPorIdPessoa(clienteCommand.IdPessoa.Value);
endereco.AtualizarDados(clienteCommand.Endereco.Logradouro, clienteCommand.Endereco.Numero, clienteCommand.Endereco.Complemento,
clienteCommand.Endereco.Bairro, clienteCommand.Endereco.CidadeId, clienteCommand.Endereco.EstadoId,
clienteCommand.Endereco.Cep);
var enderecoRetorno = _enderecoService.Atualizar(endereco);
clienteRetorno.AdicionarEndereco(enderecoRetorno);
if (Commit())
{
return(ClienteAdapter.ToModelDomain(clienteRetorno));
}
return(null);
}
public IActionResult Put([FromBody] Cliente cliente)
{
var at = _clienteService.Atualizar(cliente);
Commit();
return(Response(at));
}
public ClienteViewModel Atualizar(ClienteViewModel clienteViewModel)
{
// Aqui estamos extraindo o cliente de domínio
var cliente = Mapper.Map <Cliente>(clienteViewModel);
if (!cliente.EhValido())
{
return(clienteViewModel);
}
var clienteReturn = _clienteService.Atualizar(cliente);
if (clienteReturn.ValidationResult.IsValid)
{
if (!SaveChanges())
{
AdicionarErrosValidacao(cliente.ValidationResult, "Ocorreu um erro no momento de salvar os dados no banco.");
}
}
// Em caso de erros estou devolvendo eles para a camada de apresentação na classe ClienteViewModel
clienteViewModel.ValidationResult = clienteReturn.ValidationResult;
return(clienteViewModel);
}
public ClienteViewModel Atualizar(ClienteViewModel clienteViewModel)
{
var cliente = Mapper.Map <Cliente>(clienteViewModel);
_clienteService.Atualizar(cliente);
return(clienteViewModel);
}
public ClienteViewModel Atualizar(ClienteViewModel clienteViewModel)
{
var cliente = Mapper.Map <Cliente>(clienteViewModel);
_clienteService.Atualizar(cliente);
cliente.Ativo = true; //gambi
Commit(); //gambi
return(clienteViewModel);
}
public async Task <IActionResult> Alterar(long id, [FromBody] Cliente cliente, CancellationToken ct = default)
{
if (id != cliente.Id)
{
NotificarErro("Erro ao atualizar!");
return(CustomResponse());
}
return(CustomResponse(await _clienteService.Atualizar(cliente, ct)));
}
public ActionResult <ClienteDto> Put(int id, ClienteDto cliente)
{
if (id != cliente.Id)
{
return(BadRequest());
}
_clienteService.Atualizar(cliente);
return(NoContent());
}
public async Task <ActionResult <ClienteViewModel> > Atualizar(Guid id, ClienteViewModel clienteViewModel)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _clienteService.Atualizar(id, _mapper.Map <Cliente>(clienteViewModel));
return(CustomResponse(clienteViewModel));
}
public async Task <IActionResult> Atualizar([FromBody] AtualizarClienteDto cliente)
{
var response = await _clienteService.Atualizar(cliente);
if (!response.Sucess)
{
return(BadRequest(response));
}
return(Ok(response));
}
public void Atualizar(Cliente cliente)
{
var clienteResult = _clienteService.ObterPorIdAsync(cliente.Id);
if (clienteResult.Result == null)
{
throw new BusinessException("Cliente não localizado");
}
_clienteService.Atualizar(cliente);
}
public ClienteViewModel Atualizar(ClienteViewModel clienteViewModel)
{
var cliente = Mapper.Map <ClienteViewModel, Cliente>(clienteViewModel);
var clienteReturn = _clienteService.Atualizar(cliente);
if (clienteReturn.ValidationResult.IsValid)
{
Commit();
}
return(clienteViewModel);
}
public void Atualizar(ClienteEnderecoVM clienteEnderecoVm)
{
// var cliente = Mapper.Map<ClienteVM, Cliente>(clienteVm);
var cliente = Mapper.Map <ClienteEnderecoVM, Cliente>(clienteEnderecoVm);
var endereco = Mapper.Map <ClienteEnderecoVM, Endereco>(clienteEnderecoVm);
cliente.Enderecos.Add(endereco);
BeginTransaction();
_clienteRepository.Atualizar(cliente);
Commit();
}
public async Task <ClienteViewModel> Atualizar(ClienteViewModel clienteViewModel)
{
var cliente = _mapper.Map <Cliente>(clienteViewModel);
cliente = await _clienteService.Atualizar(cliente);
//if (clienteReturn.ValidationResult.IsValid)
//Commit();
clienteViewModel = _mapper.Map <ClienteViewModel>(cliente);
return(clienteViewModel);
}
public ViewUpdateClienteViewModel Atualizar(ViewUpdateClienteViewModel clienteViewModel)
{
var cliente = _mapper.Map <Cliente>(clienteViewModel);
var clienteResult = _clienteService.Atualizar(cliente);
if (clienteResult.ValidationResult.IsValid)
{
commit();
}
clienteViewModel = _mapper.Map <ViewUpdateClienteViewModel>(clienteResult);
return(clienteViewModel);
}
public ClienteViewModel Atualizar(ClienteViewModel clienteViewModel)
{
var cliente = AutoMapperSingleton.GetInstance().Map <Cliente>(clienteViewModel);
var clienteReturn = _clienteService.Atualizar(cliente);
if (clienteReturn.ValidationResult.IsValid)
{
Commit();
}
clienteViewModel = AutoMapperSingleton.GetInstance().Map <ClienteViewModel>(clienteReturn);
return(clienteViewModel);
}
public ClienteViewModel Atualizar(ClienteViewModel ClienteViewModel)
{
var Cliente = Mapper.Map <Cliente>(ClienteViewModel);
var ClienteRet = _ClienteService.Atualizar(Cliente);
if (Cliente.ValidationResult.IsValid)
{
Commit();
ClienteRet.ValidationResult.Message = "Cliente Editada com sucesso";
}
ClienteViewModel = Mapper.Map <ClienteViewModel>(ClienteRet);
return(ClienteViewModel);
}
public IActionResult Atualizar([FromBody] Cliente cliente, Guid uuid)
{
try
{
if (_clienteService.Atualizar(cliente, uuid))
{
return(new OkResult());
}
return(new NotFoundResult());
}
catch (Exception exception)
{
Console.WriteLine(exception);
return(new BadRequestResult());
}
}
public async Task <ActionResult <ClienteViewModel> > Atualizar(Guid id, ClienteViewModel clienteViewModel)
{
if (id != clienteViewModel.Id)
{
NotificarErro("O id informado não é o mesmo");
return(CustomResponse(clienteViewModel));
}
if (!ModelState.IsValid)
{
return(CustomResponse(clienteViewModel));
}
await _clienteService.Atualizar(_mapper.Map <Cliente>(clienteViewModel));
return(CustomResponse(clienteViewModel));
}
public HttpResponseMessage Editar([FromBody] ClienteAtualizarViewModel viewModel)
{
if (viewModel == null)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Json inválido."));
}
var clienteDtoReturn = _clienteService.Atualizar(viewModel);
if (clienteDtoReturn.Erros.Count > 0)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, clienteDtoReturn.Erros));
}
return(Request.CreateResponse(HttpStatusCode.Created, clienteDtoReturn.Cliente));
}
public async Task <IActionResult> AtualizarCliente([FromBody] AtualizarClienteViewModel model)
{
var cliente = await _clienteRepository.ObterPorId(UsuarioId);
if (cliente == null)
{
NotificarErro("AtualizarCliente", "Cliente não encontrado.");
return(BadRequest());
}
cliente.AlterarDadosCadastrais(model.Nome, model.Sobrenome);
await _clienteService.Atualizar(cliente);
return(Response(cliente.Id));
}
public ClienteViewModel Atualizar(ClienteViewModel clienteViewModel)
{
var client = _clienteService.ObterPorId(clienteViewModel.ClienteId);
client.Ativo = true;
var cliente = Mapper.Map(clienteViewModel, client);
//_clienteService.Atualizar(cliente);
cliente.Ativo = true;
var clienteReturn = _clienteService.Atualizar(cliente);
Commit();
return(clienteViewModel);
}
public async Task <ActionResult <ClienteViewModel> > Atualizar(Guid id, ClienteViewModel ClienteViewModel)
{
if (id != ClienteViewModel.Id)
{
NotificarErro("O id informado não é o mesmo que foi passado na query");
return(CustomResponse(ClienteViewModel));
}
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _clienteService.Atualizar(_mapper.Map <Cliente>(ClienteViewModel, Tratamento));
return(CustomResponse(ClienteViewModel));
}
