public IActionResult Put(Guid id, [FromBody] AtualizarUsuarioCommand command)
{
command.Id = id;
var service = new AtualizarUsuarioService(command, _usuarioRepo);
return(ReturnResponse(service, new { message = "Usuário atualizado com sucesso" }, null));
}
public ICommandResult <Notificacao> Handler(AtualizarUsuarioCommand command)
{
try
{
Usuario usuario = UsuarioHelper.GerarEntidade(command);
AddNotificacao(usuario.Login.Notificacoes);
AddNotificacao(usuario.Senha.Notificacoes);
if (!_repository.CheckId(usuario.Id))
{
AddNotificacao("Id", "Id inválido. Este id não está cadastrado!");
}
if (_repository.CheckLogin(usuario.Login.ToString()))
{
AddNotificacao("Login", "Esse login não está disponível pois já está sendo usado por outro usuário");
}
if (Invalido)
{
return(new CommandResult <Notificacao>("Inconsistência(s) no(s) dado(s)", Notificacoes));
}
_repository.Atualizar(usuario);
AtualizarUsuarioCommandOutput dadosRetorno = UsuarioHelper.GerarDadosRetornoUpdate(usuario);
return(new CommandResult <Notificacao>("Usuário atualizado com sucesso!", dadosRetorno));
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public AtualizarUsuarioService(AtualizarUsuarioCommand command, IUsuarioRepository repository) : base(command)
{
_command = command;
_repository = repository;
this.Run();
}
public async Task <CommandResult> Handle(AtualizarUsuarioCommand request, CancellationToken cancellationToken)
{
var usuario = UsuarioFactory.Create(request);
_usuarioRepository.Atualizar(usuario);
_usuarioRepository.SaveChanges();
var resultado = _managerResult.Success("Usuário atualizado com sucesso.");
return(await Task.FromResult(resultado));
}
public ICommandResult UsuarioPut(int id, [FromBody] AtualizarUsuarioCommand command)
{
try
{
command.Id = id;
return(_handler.Handle(command));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <UsuarioModel> AtualizarUsuarioAsync(Guid usuarioId, AtualizarUsuarioRequest request)
{
var atualizarUsuarioCommand = new AtualizarUsuarioCommand
{
UsuarioId = usuarioId,
Usuario = _mapper
.Map <UsuarioModel>(request)
};
var result = await _mediator
.Send(atualizarUsuarioCommand);
return(result);
}
public void DeveSer_Invalido_Quando_Id_Nao_Informado()
{
var command = new AtualizarUsuarioCommand
{
Nome = "Alexandre",
Sobrenome = "Del Picolo",
Email = "*****@*****.**",
DataNascimento = DateTime.Now.AddYears(-1),
Perfil = (int)Perfil.Administrador
};
var modelState = new AtualizarUsuarioCommandValidator().Validate(command);
Assert.IsTrue(modelState.Errors.Any(x => x.PropertyName == nameof(command.Id)));
}
public ICommandResult Handle(AtualizarUsuarioCommand command)
{
try
{
if (!command.ValidarCommand())
{
return(new CommandResult(false, "Por favor, corrija as inconsistências abaixo", command.Notifications));
}
int id = command.Id;
string nome = command.Nome;
Email login = new Email(command.Login);
string senha = command.Senha;
Usuario usuario = new Usuario(id, nome, login, senha);
AddNotifications(login.Notifications);
if (usuario.Id == 0)
{
AddNotification("Id", "Id não está vinculado à operação solicitada");
}
if (!_repository.CheckId(usuario.Id))
{
AddNotification("Id", "Este Id não está cadastrado! Impossível prosseguir com este Id.");
}
if (Invalid)
{
return(new CommandResult(false, "Por favor, corrija as inconsistências abaixo", Notifications));
}
_repository.Atualizar(usuario);
return(new CommandResult(true, "Usuário atualizado com sucesso!", new
{
Id = usuario.Id,
Nome = usuario.Nome,
Login = usuario.Login.ToString(),
Senha = usuario.Senha
}));
}
catch (Exception ex)
{
throw ex;
}
}
public ICommandResult Handle(AtualizarUsuarioCommand command)
{
int id = command.Id;
NomenclaturaPadrao nome = new NomenclaturaPadrao(command.Nome);
CPF cpf = new CPF(command.CPF);
Email email = new Email(command.Email);
DateTime dataNascimento = command.DataNascimento;
UF estado = new UF(command.Estado);
CEP cep = new CEP(command.CEP);
string cidade = command.Cidade;
Usuario usuario = new Usuario(id, nome, cpf, email, dataNascimento, cep, estado, cidade);
//Valida Entidade e Vo's
AddNotifications(usuario.Notifications);
//Validar Dependências
if (usuario.Id == 0)
{
AddNotification("Id", "Id não está vinculada à operação solicitada");
}
if (Invalid)
{
return(new UsuarioCommandResult(false, "Por favor, corrija as inconsistências abaixo", Notifications));
}
//Persiste os dados
string ret = _repository.Atualizar(usuario, usuario.Id);
//Notifica
if (ret == "Sucesso")
{
// Retornar o resultado para tela
return(new UsuarioCommandResult(true, "Usuário atualizado com sucesso!", new
{
Id = usuario.Id,
CPF = usuario.CPF.ToString(),
Nome = usuario.Nome.ToString()
}));
}
else
{
// Retornar o resultado para tela
return(new UsuarioCommandResult(false, "Por favor, corrija as inconsistências abaixo", ret));
}
}
public static Usuario GerarEntidade(AtualizarUsuarioCommand command)
{
try
{
int id = command.Id;
Texto login = new Texto(command.Login, "Login", 50);
SenhaMedia senha = new SenhaMedia(command.Senha);
EPrivilegioUsuario privilegio = command.Privilegio;
Usuario usuario = new Usuario(id, login, senha, privilegio);
return(usuario);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public Task <HttpResponseMessage> AtualizarUsuario([FromUri] int id, [FromBody] AtualizarUsuarioCommand command)
{
var response = new HttpResponseMessage();
try
{
var responseMessage = _mediator.Send(command).Result;
}
catch (Exception)
{
//response = Request.CreateResponse(HttpStatusCode.OK, new { code = (int)HttpStatusCode.BadRequest, status = MESSAGE_ERROR, data = new { message = ex.Message } });
}
var tsc = new TaskCompletionSource <HttpResponseMessage>();
tsc.SetResult(response);
return(tsc.Task);
}
public async Task Handle_UsuarioHandler_AtualizarUsuario()
{
var comando = new AtualizarUsuarioCommand
{
UsuarioId = _memoryDb.Usuarios.Last().Id,
Usuario = new UsuarioModel
{
Nome = new Faker().Person.FirstName,
Sobrenome = new Faker().Person.LastName,
Email = "*****@*****.**",
TipoUsuario = TipoUsuario.Jogador
}
};
var cmdResult = await _mediator.Send(comando);
cmdResult.Should().NotBeNull();
var updatedUser = _memoryDb.Usuarios.Last();
updatedUser.Nome.Should().Be(comando.Usuario.Nome);
updatedUser.Sobrenome.Should().Be(comando.Usuario.Sobrenome);
updatedUser.TipoUsuario.Should().Be(comando.Usuario.TipoUsuario);
}
public async Task <IActionResult> AtualizarUsuarioAsync([FromBody] AtualizarUsuarioCommand usuario)
{
var result = await _mediator.Send(usuario);
return(this.VerificarErros(_notifications, result));
}
public async Task <CommandResult> Atualizar([FromRoute] long id, [FromBody] AtualizarUsuarioCommand command)
{
command.Id = id;
return(await _mediator.Send(command));
}
public async Task <UsuarioModel> Handle(AtualizarUsuarioCommand request, CancellationToken cancellationToken)
{
return(await _usuarioServico.AtualizarUsuarioAsync(request.UsuarioId, request.Usuario));
}
public ICommandResult UsuarioAlterar([FromBody] AtualizarUsuarioCommand command)
{
return((UsuarioCommandResult)_handler.Handle(command));
}
public ActionResult <ApiResponse <AtualizarUsuarioCommandOutput, Notificacao> > UsuarioAlterar([FromBody] AtualizarUsuarioCommand command)
{
try
{
if (Request.Headers["ChaveAPI"].ToString() != _ChaveAPI)
{
return(StatusCode(StatusCodes.Status401Unauthorized, new ApiResponse <object, Notificacao>("Acesso negado", new List <Notificacao>()
{
new Notificacao("Chave da API", "ChaveAPI não corresponde com a chave esperada")
})));
}
if (command == null)
{
return(StatusCode(StatusCodes.Status400BadRequest, new ApiResponse <object, Notificacao>("Parâmentros inválidos", new List <Notificacao>()
{
new Notificacao("Parâmetros de entrada", "Parâmetros de entrada estão nulos")
})));
}
if (!command.ValidarCommand())
{
return(StatusCode(StatusCodes.Status400BadRequest, new ApiResponse <object, Notificacao>("Parâmentros inválidos", command.Notificacoes)));
}
var result = _handler.Handler(command);
if (result.Sucesso)
{
return(StatusCode(StatusCodes.Status200OK, new ApiResponse <object, Notificacao>(result.Mensagem, result.Dados)));
}
else
{
return(StatusCode(StatusCodes.Status400BadRequest, new ApiResponse <object, Notificacao>(result.Mensagem, result.Erros)));
}
}
catch (Exception e)
{
return(StatusCode(StatusCodes.Status500InternalServerError, new ApiResponse <object, Notificacao>("Erro", new List <Notificacao>()
{
new Notificacao("Erro", e.Message)
})));
}
}
