public IActionResult Put(ClienteEdicaoModel model)
{
//verificar se algum campo da model está com erro!
if (!ModelState.IsValid)
{
return(BadRequest()); //HTTP 400 (BadRequest)
}
try
{
var cliente = clienteRepository.ObterPorId(model.IdCliente);
if (cliente == null) //se cliente não foi encontrado
{
return(BadRequest("Cliente não encontrado."));
}
cliente.Nome = model.Nome;
cliente.Email = model.Email;
clienteRepository.Alterar(cliente);
var result = new
{
mensagem = "Cliente atualizado com sucesso.",
cliente //dados do cliente atualizado no banco
};
return(Ok(result));
}
catch (Exception e)
{
return(StatusCode(500, "Erro: " + e.Message));
}
}
[HttpPost] //método recebe o SUBMIT do formulário
public IActionResult Edicao(ClienteEdicaoModel model, [FromServices] ClienteRepository clienteRepository)
{
if (ModelState.IsValid)
{
try
{
var cliente = new Cliente();
cliente.IdCliente = model.IdCliente;
cliente.Nome = model.Nome;
cliente.Email = model.Email;
cliente.Cpf = model.Cpf;
//atualizando no banco de dados
clienteRepository.Update(cliente);
TempData["MensagemSucesso"] = "Cliente atualizado com sucesso.";
}
catch (Exception e)
{
TempData["MensagemErro"] = e.Message;
}
}
return(View()); //abrir uma página
}
public IActionResult Put(ClienteEdicaoModel model,
[FromServices] ClienteRepository clienteRepository)
{
try
{
//buscando o cliente na base de dados pelo id
var cliente = clienteRepository.GetById(model.IdCliente);
//verificando se o cliente foi encontrado
if (cliente != null)
{
cliente.Nome = model.Nome;
cliente.Cpf = model.Cpf;
cliente.Email = model.Email;
//atualizando o cliente
clienteRepository.Update(cliente);
//retornar status 200 (OK)
return(Ok("Cliente atualizado com sucesso."));
}
else
{
//retornar status 422 (Unprocessable Entity)
return(StatusCode(422, "Cliente inválido. Operação não pôde ser realizada."));
}
}
catch (Exception e)
{
//retornar status 500 (Internal Server Error)
return(StatusCode(500, "Ocorreu um erro: " + e.Message));
}
}
[Fact] //método para execução de teste do XUnit
//async -> método executado como uma Thread (assincrono)
public async Task Cliente_Put_ReturnsOk()
{
//--------------cadastrando um cliente na API
var modelCadastro = new ClienteCadastroModel()
{
Nome = "Sergio Mendes",
Email = "*****@*****.**"
};
var requestCadastro = SerializarObjeto(modelCadastro);
var responseCadastro = await appContext.Client.PostAsync(endpoint, requestCadastro);
var respostaCadastro = DeserializarObjeto(responseCadastro);
//verificação de teste
responseCadastro.StatusCode.Should().Be(HttpStatusCode.OK);
respostaCadastro.Mensagem.Should().Be("Cliente cadastrado com sucesso.");
//--------------atualizando o cliente cadastrado na API
var modelEdicao = new ClienteEdicaoModel()
{
IdCliente = respostaCadastro.Cliente.IdCliente,
Nome = "Sergio da Silva Mendes",
Email = "*****@*****.**"
};
var requestEdicao = SerializarObjeto(modelEdicao);
var responseEdicao = await appContext.Client.PutAsync(endpoint, requestEdicao);
var respostaEdicao = DeserializarObjeto(responseEdicao);
//verificação de teste
responseEdicao.StatusCode.Should().Be(HttpStatusCode.OK);
respostaEdicao.Mensagem.Should().Be("Cliente atualizado com sucesso.");
}
public IActionResult Put(ClienteEdicaoModel model)
{
//verificando se os campos da model passaram nas validações
if (ModelState.IsValid)
{
try
{
var cliente = mapper.Map <Cliente>(model);
clienteRepository.Alterar(cliente);
var result = new
{
message = "Cliente atualizado com sucesso",
cliente
};
return(Ok(result)); //HTTP 200 (SUCESSO!)
}
catch (Exception e)
{
return(StatusCode(500, "Erro: " + e.Message));
}
}
else
{
//Erro HTTP 400 (BAD REQUEST)
return(BadRequest("Ocorreram erros de validação."));
}
}
public IActionResult Put(ClienteEdicaoModel model, [FromServices] IClienteRepository repository)
{
if (ModelState.IsValid)
{
try
{
Cliente cliente = new Cliente();
cliente.IdCliente = model.IdCliente;
cliente.Nome = model.Nome;
cliente.Email = model.Email;
repository.Atualizar(cliente);
return(Ok($"Cliente {cliente.Nome} atualizado com sucesso"));
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
else
{
return(StatusCode(400, "Ocorreram erro de validação"));
}
}
public ClienteDTO Update(ClienteEdicaoModel model)
{
var cliente = mapper.Map <Cliente>(model);
ClienteDomainService.Update(cliente);
return(mapper.Map <ClienteDTO>(cliente));
}
public async Task Cliente_Put_ReturnsBadRequest()
{
var model = new ClienteEdicaoModel();
var request = new StringContent(JsonConvert.SerializeObject(model),
Encoding.UTF8, "application/json");
var response = await appContext.Client.PutAsync(endpoint, request);
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
[Fact] //método para execução de teste do XUnit
//async -> método executado como uma Thread (assincrono)
public async Task Cliente_Put_ReturnsOk()
{
//--------------cadastrando um cliente na API
var modelCadastro = new ClienteCadastroModel()
{
Nome = "Sergio Mendes",
Email = "*****@*****.**"
};
var requestCadastro = new StringContent(JsonConvert.SerializeObject(modelCadastro),
Encoding.UTF8, "application/json");
var responseCadastro = await appContext.Client.PostAsync(endpoint, requestCadastro);
var resultCadastro = string.Empty;
using (HttpContent content = responseCadastro.Content)
{
Task <string> r = content.ReadAsStringAsync();
resultCadastro += r.Result;
}
var respostaCadastro = JsonConvert.DeserializeObject <ResultModel>(resultCadastro);
//verificação de teste
responseCadastro.StatusCode.Should().Be(HttpStatusCode.OK);
respostaCadastro.Mensagem.Should().Be("Cliente cadastrado com sucesso.");
//--------------atualizando o cliente cadastrado na API
var modelEdicao = new ClienteEdicaoModel()
{
IdCliente = respostaCadastro.Cliente.IdCliente,
Nome = "Sergio da Silva Mendes",
Email = "*****@*****.**"
};
var requestEdicao = new StringContent(JsonConvert.SerializeObject(modelEdicao),
Encoding.UTF8, "application/json");
var responseEdicao = await appContext.Client.PutAsync(endpoint, requestEdicao);
var resultEdicao = string.Empty;
using (HttpContent content = responseEdicao.Content)
{
Task <string> r = content.ReadAsStringAsync();
resultEdicao += r.Result;
}
var respostaEdicao = JsonConvert.DeserializeObject <ResultModel>(resultEdicao);
//verificação de teste
responseEdicao.StatusCode.Should().Be(HttpStatusCode.OK);
respostaEdicao.Mensagem.Should().Be("Cliente atualizado com sucesso.");
}
public void Update(ClienteEdicaoModel model)
{
var cliente = new Cliente();
cliente.Id = model.Id;
cliente.Nome = model.Nome;
cliente.Email = model.Email;
cliente.Cpf = model.Cpf;
cliente.PlanoId = model.PlanoId;
clienteDomainService.Update(cliente);
}
public IActionResult Put(ClienteEdicaoModel model,
[FromServices] IClienteApplicationService clienteApplicationService)
{
try
{
clienteApplicationService.Update(model);
return(Ok("Cliente Alterado com sucesso."));
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
[Fact] //método para execução de teste do XUnit
//async -> método executado como uma Thread (assincrono)
public async Task Cliente_Put_ReturnsBadRequest()
{
//preencher os campos da model
var model = new ClienteEdicaoModel()
{
IdCliente = 0,
Nome = string.Empty, //vazio
Email = string.Empty //vazio
};
//montando os dados em JSON que serão enviados para a API
var request = SerializarObjeto(model);
var response = await appContext.Client.PutAsync(endpoint, request);
//critério de teste (Serviço da API retornar HTTP BADREQUEST (400))
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
public IActionResult Put(ClienteEdicaoModel model)
{
try
{
var result = clienteApplicationService.Update(model);
return(Ok(new
{
Message = "cliente atualizado com sucesso.",
cliente = result
}));
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
public IActionResult Put(ClienteEdicaoModel model)
{
try
{
var clienteDTO = _clienteApplicationService.Update(model);
return(StatusCode(200, new
{
Message = "Aluno atualizado com sucesso.",
Cliente = clienteDTO
}));
}
catch (Exception e)
{
return(StatusCode(500, new { e.Message }));
}
}
public ClienteDTO Update(ClienteEdicaoModel model)
{
var aluno = _clienteDomainService.GetById(model.IdCliente);
if (aluno == null)
{
throw new Exception("Aluno não encontrado");
}
aluno.Nome = model.Nome;
aluno.DataNascimento = model.DataDeNascimento;
aluno.Email = model.Email;
_clienteDomainService.Update(aluno);
var alunoModel = _mapper.Map <ClienteDTO>(aluno);
return(alunoModel);
}
public async Task Cliente_Put_ReturnsOk()
{
var random = new Random();
var model = new ClienteCadastroModel();
model.Nome = "Vladimir Portella";
model.DataNascimento = new DateTime(1994, 10, 25);
model.Telefone = "981373216";
model.Cpf = random.Next(99999999, 999999999).ToString();
model.Email = $"vladimir{random.Next(99, 9999)}@gmail.com";
var request = new StringContent(JsonConvert.SerializeObject(model),
Encoding.UTF8, "application/json");
var response = await appContext.Client.PostAsync(endpoint, request);
response.StatusCode.Should().Be(HttpStatusCode.OK);
var result = ObterDadosSucesso(response);
var modelEdicao = new ClienteEdicaoModel();
modelEdicao.IdCliente = result.Cliente.IdCliente;
modelEdicao.Nome = "Vladimir Portella - Edição";
modelEdicao.Telefone = result.Cliente.Telefone;
modelEdicao.Cpf = result.Cliente.Cpf;
modelEdicao.Email = result.Cliente.Email;
modelEdicao.DataNascimento = result.Cliente.DataNascimento;
var requestEdicao = new StringContent(JsonConvert.SerializeObject(modelEdicao),
Encoding.UTF8, "application/json");
var responseEdicao = await appContext.Client.PutAsync(endpoint, requestEdicao);
responseEdicao.StatusCode.Should().Be(HttpStatusCode.OK);
var resultEdicao = ObterDadosSucesso(responseEdicao);
resultEdicao.Mensagem.Should().Contain("Cliente atualizado com sucesso");
resultEdicao.Cliente.Nome.Should().Equals(modelEdicao.Nome);
}
public IActionResult Put(ClienteEdicaoModel model, [FromServices] IClienteDomainService clienteDomainService)
{
if (ModelState.IsValid)
{
try
{
var cliente = clienteDomainService.ObterPorId(model.IdCliente);
if (cliente != null)
{
cliente.Nome = model.Nome;
cliente.Email = model.Email;
cliente.Cpf = model.Cpf;
cliente.Telefone = model.Telefone;
cliente.DataNascimento = model.DataNascimento;
clienteDomainService.AtualizarCliente(cliente);
var result = new ClienteSucessoModel();
result.Mensagem = "Cliente atualizado com sucesso";
result.Cliente = cliente;
return(Ok(result));
}
else
{
return(BadRequest("Cliente não encontrado"));
}
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
else
{
return(BadRequest());
}
}
public IActionResult Edicao(int id, [FromServices] ClienteRepository clienteRepository)
{
//criando um objeto da classe model
var model = new ClienteEdicaoModel();
try
{
//buscando o cliente no banco de dados pelo id
var cliente = clienteRepository.GetById(id);
//transferir os dados do cliente para a model
model.IdCliente = cliente.IdCliente;
model.Nome = cliente.Nome;
model.Email = cliente.Email;
model.Cpf = cliente.Cpf;
}
catch (Exception e)
{
TempData["MensagemErro"] = e.Message;
}
return(View(model)); //abrir uma página
}
public HttpResponseMessage Atualizar(ClienteEdicaoModel model)
{
if (ModelState.IsValid)
{
try
{
Cliente c = new Cliente();
c.IdCliente = model.IdCliente;
c.Nome = model.Nome;
c.Email = model.Email;
ClienteRepositorio rep = new ClienteRepositorio();
rep.Atualizar(c);
return(Request.CreateResponse(HttpStatusCode.OK,
"Cliente atualizado com sucesso."));
}
catch (Exception e)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, e.Message));
}
}
else
{
List <string> erros = new List <string>();
foreach (var m in ModelState)
{
if (m.Value.Errors.Count > 0)
{
erros.Add(m.Value.Errors.Select(e => e.ErrorMessage).FirstOrDefault());
}
}
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
}
public IActionResult Put(ClienteEdicaoModel model,
[FromServices] IClienteRepository repository,
[FromServices] IMapper mapper)
{
if (ModelState.IsValid)
{
try
{
var cliente = mapper.Map <Cliente>(model);
repository.Atualizar(cliente);
return(Ok("Cliente atualizado com sucesso."));
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
else
{
return(BadRequest());
}
}
public IActionResult Put(ClienteEdicaoModel model)
{
if (ModelState.IsValid)
{
try
{
service.Atualizar(model);
var result = new
{
message = "Cliente atualizado com sucesso"
};
return(Ok(result));
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
else
{
return(BadRequest()); //HTTP 400
}
}
[HttpPut] //requisição do tipo PUT
public HttpResponseMessage Put(ClienteEdicaoModel model)
{
if (ModelState.IsValid)
{
try
{
var cliente = Mapper.Map <Cliente>(model);
ClienteRepository repository = new ClienteRepository();
repository.Update(cliente);
//retornando um status de sucesso!
return(Request.CreateResponse
(HttpStatusCode.OK, "Cliente atualizado com sucesso."));
}
catch (Exception e)
{
//HTTP 500 -> Internal Server Error
return(Request.CreateResponse(HttpStatusCode.InternalServerError, e.Message));
}
}
//HTTP 400 -> BadRequest
return(Request.CreateResponse(HttpStatusCode.BadRequest, ValidationUtil.GetErrors(ModelState)));
}
public void Atualizar(ClienteEdicaoModel model)
{
var cliente = Mapper.Map <ClienteEntity>(model);
domainService.Atualizar(cliente);
}
