public async Task ShouldInvalidateAlterarUsuarioCommandWhenAlreadyUsuarioWithSameSigla()
{
var usuario = new Usuario
{
Id = 1,
Nome = "Teste",
Sigla = "FFF",
Status = StatusDeCadastro.Normal,
SetorId = 1,
Login = "******",
Senha = "teste"
};
_repositoryMock.Setup(r => r.Usuario.GetUsuarioByIdAsync(1)).Returns(Task.FromResult(usuario));
_repositoryMock.Setup(r => r.Usuario.GetUsuarioBySiglaAndDiferentIdAsync(1, "FFF")).Returns(Task.FromResult(usuario));
var command = new AlterarUsuarioCommand(
usuario.Id,
usuario.Nome,
usuario.Sigla,
usuario.SetorId,
usuario.Status,
usuario.Login,
usuario.Senha
);
var result = await _usuarioHandler.Handler(command);
Assert.AreEqual("Já existe um usuário com a mesma sigla cadastrada", ((CommandResult)result).Message);
}
public Task <bool> Handle(AlterarUsuarioCommand message, CancellationToken cancellationToken)
{
#region Basic Validations
if (!message.IsValid())
{
NotifyValidationErrors(message);
return(Task.FromResult(false));
}
#endregion
var password = Encription.Encrypt(message.Password, Encription.Key256, 256);
var usuario = new Usuario(
message.Id, message.Nome, message.Idade, message.Documento, message.TipoDocumento,
message.Genero, message.Pai, message.Mae, message.Telefone, message.Celular, message.Email, password, message.UsuarioId
);
_usuarioRepository.Update(usuario);
if (Commit())
{
_bus.RaiseEvent(new AlterarUsuarioEvent());
}
return(Task.FromResult(true));
}
public async Task ShouldInvalidateAlterarProjetoCommandWhenNotFoundSetorById()
{
var usuario = new Usuario
{
Id = 1,
Nome = "Teste",
Sigla = "FFF",
Status = StatusDeCadastro.Normal,
SetorId = 1,
Login = "******",
Senha = "teste"
};
_repositoryMock.Setup(r => r.Usuario.GetUsuarioByIdAsync(1));
var command = new AlterarUsuarioCommand(
usuario.Id,
usuario.Nome,
usuario.Sigla,
usuario.SetorId,
usuario.Status,
usuario.Login,
usuario.Senha
);
var result = await _usuarioHandler.Handler(command);
Assert.AreEqual("Usuário não encontrado", ((CommandResult)result).Message);
}
public ICommandResult Handle(AlterarUsuarioCommand command)
{
//Fail Fast Validation
command.Validate();
if (command.Invalid)
{
return(new GenericCommandResult(false, _msgError, command.Notifications));
}
var usuario = _usuario_repository.ObterPorId(command.IdUsuario);
usuario.AtivarDesativar(command.Ativo);
_usuario_repository.Atualizar(usuario);
//Busca a claim informada no request
var claim = _claims_repository.ObterPorNomeValor("PerfilAcesso", command.Perfil);
var claimUsuario = _usuario_claims_repository.ObterClaimsUsuario(usuario.IdFirebase).FirstOrDefault();
_usuario_claims_repository.Remover(claimUsuario);
//Vincular a claim ao usuario
_usuario_claims_repository.Criar(new UsuarioClaims
{
UsuarioId = usuario.Id,
ClaimId = claim.Id
});
//Retorna o resultado
return(new GenericCommandResult(true, "Usuario alterado com Sucesso!", null));
}
public void AlterarUsuarioComNomeInvalido(string nome)
{
var command = new AlterarUsuarioCommand(Guid.NewGuid(), nome);
var validator = new AlterarUsuarioValidator();
var result = validator.Validate(command);
Assert.False(result.IsValid);
Assert.Contains(result.Errors, e => String.Equals("Nome", e.PropertyName));
}
public void ShouldInvalidateAlterarUsuarioCommandWhenIdDepartamentIsZero()
{
var alterarUsuarioCommand = new AlterarUsuarioCommand(1, "teste", "FFF", 0, StatusDeCadastro.Normal, "", "teste123");
alterarUsuarioCommand.Validate();
var result = alterarUsuarioCommand.Notifications.ToList();
Assert.AreEqual(result[0].Message, "Obrigatório informar um setor com id válido");
}
public void SucessoCasoDadosAterarCommandValidosComTelefone()
{
var _command = new AlterarUsuarioCommand(Guid.NewGuid(), "Nome alterar command", "*****@*****.**", "11962553590");
//Validando os campos informados
_command.Validar();
//Espera sucesso ao inserir um novo usuário
Assert.True(_command.Valid, "Os dados informados estão incorretos");
}
public void ShouldInvalidateAlterarUsuarioCommandWhenNameIsGreaterThan30()
{
var alterarUsuarioCommand = new AlterarUsuarioCommand(1, "dhasghghghaghdgashdghgdhjghasgdjhagddhasghg", "teste", 1, StatusDeCadastro.Normal, "luism", "teste123");
alterarUsuarioCommand.Validate();
var result = alterarUsuarioCommand.Notifications.ToList();
Assert.AreEqual(result[0].Message, "Nome não pode ser maior que 30 caracteres.");
}
public void ShouldInvalidateAlterarUsuarioCommandWhenPasswordGreaterThan8()
{
var alterarUsuarioCommand = new AlterarUsuarioCommand(1, "teste", "FFF", 1, StatusDeCadastro.Normal, "luism", "teste123456");
alterarUsuarioCommand.Validate();
var result = alterarUsuarioCommand.Notifications.ToList();
Assert.AreEqual(result[0].Message, "Senha não pode ser maior que 8 caracteres.");
}
public void ShouldInvalidateUpdateUserWhenInitialsIsLessThan2()
{
var alterarUsuarioCommand = new AlterarUsuarioCommand(1, "teste", "F", 1, StatusDeCadastro.Normal, "luism", "teste123");
alterarUsuarioCommand.Validate();
var result = alterarUsuarioCommand.Notifications.ToList();
Assert.AreEqual(result[0].Message, "Sigla deve ter no mínimo 2 caracteres.");
}
public void ShouldInvalidateAlterarUsuarioCommandWhenIdIsZero()
{
var alterarUsuarioCommand = new AlterarUsuarioCommand(0, "teste", "FFF", 1, StatusDeCadastro.Normal, "luism", "teste123");
alterarUsuarioCommand.Validate();
var result = alterarUsuarioCommand.Notifications.ToList();
Assert.AreEqual(result[0].Message, "Id do usuário inválido");
}
public void ShouldInvalidateAlterarUsuarioCommandWhenLoginIsGreaterThan20()
{
var alterarUsuarioCommand = new AlterarUsuarioCommand(1, "teste", "FFF", 1, StatusDeCadastro.Normal, "ssluismsfsffsfsfdsfsdffd", "teste123");
alterarUsuarioCommand.Validate();
var result = alterarUsuarioCommand.Notifications.ToList();
Assert.AreEqual(result[0].Message, "Login não pode ser maior que 20 caracteres.");
}
public void ShouldInvalidateAlterarUsuarioCommandWhenNameIsLessThan3()
{
var alterarUsuarioCommand = new AlterarUsuarioCommand(1, "an", "tt", 1, StatusDeCadastro.Normal, "luism", "teste123");
alterarUsuarioCommand.Validate();
var result = alterarUsuarioCommand.Notifications.ToList();
Assert.AreEqual(result[0].Message, "Nome deve ter no mínimo 3 caracteres.");
}
public void ShouldInvalidateAlterarUsuarioCommandWhenInitialsIsEmpty()
{
var alterarUsuarioCommand = new AlterarUsuarioCommand(1, "teste", "", 1, StatusDeCadastro.Normal, "luism", "teste123");
alterarUsuarioCommand.Validate();
var result = alterarUsuarioCommand.Notifications.ToList();
Assert.AreEqual(result[0].Message, "Sigla é obrigatório");
}
public void ShouldInvalidateAlterarUsuarioCommandWhenInitialsIsGreaterThan5()
{
var alterarUsuarioCommand = new AlterarUsuarioCommand(1, "teste", "FFFFFD", 1, StatusDeCadastro.Normal, "luism", "teste123");
alterarUsuarioCommand.Validate();
var result = alterarUsuarioCommand.Notifications.ToList();
Assert.AreEqual(result[0].Message, "Sigla não pode ser maior que 5 caracteres.");
}
public void ErroCasoEmailAterarCommandInvalido()
{
var _command = new AlterarUsuarioCommand(Guid.NewGuid(), "Nome alterar command", "", "11962553590");
//Validando os campos informados
_command.Validar();
//Espera erro ao alterar um command de usuário
//devido a falta de um resultado para o parametro 'email'
Assert.True(_command.Invalid, "O email informado está correto");
}
public GenericCommandResult UpdateAccount(
[FromBody] AlterarUsuarioCommand command,
[FromServices] AlterarUsuarioCommandHandler handler
)
{
var idUsuario = HttpContext.User.Claims.FirstOrDefault(c => c.Type == JwtRegisteredClaimNames.Jti);
command.IdUsuario = new Guid(idUsuario.Value);
return((GenericCommandResult)handler.Handle(command));
}
public void ErroCasoDadosAterarCommandInvalidos()
{
var _command = new AlterarUsuarioCommand(Guid.Empty, "", "", "");
//Validando os campos informados
_command.Validar();
//Espera erro ao alterar um command de usuário
//devido a falta de um resultado para o parametro 'id de usuário', 'nome', 'email', 'telefone'
Assert.True(_command.Invalid, "Os dados informados estão corretos");
}
public async void AlterarUsuario(Guid id, string nome)
{
var command = new AlterarUsuarioCommand(id, nome);
var handler = new AlterarUsuarioHandler(_query, _repository, _uow);
_query.FindById(id).Returns(new Usuario(id, nome));
var result = await handler.Handle(command, CancellationToken.None);
var model = result.GetModel <UsuarioResult>();
Assert.True(result.IsValid);
Assert.Equal(id, model.Id);
Assert.Equal(nome, model.Nome);
}
public async Task ShouldUpdateProjectWithAlterarUsuarioCommandValid()
{
var usuario = new Usuario
{
Id = 1,
Nome = "Teste",
Sigla = "FFF",
Status = StatusDeCadastro.Normal,
SetorId = 1,
Login = "******",
Senha = "teste"
};
var command = new AlterarUsuarioCommand(
usuario.Id,
usuario.Nome,
usuario.Sigla,
usuario.SetorId,
usuario.Status,
usuario.Login,
usuario.Senha
);
var setor = new Setor
{
Id = 1,
Nome = "Teste"
};
_mapperMock.Setup(m => m.Map <Usuario>(command)).Returns(usuario);
_cryptographyServiceMock.Setup(c => c.Encrypt(usuario.Senha)).Returns("senha");
_repositoryMock.Setup(r => r.Usuario.GetUsuarioByIdAsync(1)).Returns(Task.FromResult(usuario));
_repositoryMock.Setup(r => r.Setor.GetSetorByIdAsync(1)).Returns(Task.FromResult(setor));
_repositoryMock.Setup(r => r.Usuario.Update(usuario));
_repositoryMock.Setup(r => r.SaveAsync());
var result = await _usuarioHandler.Handler(command);
Assert.AreEqual("Dados alterados com sucesso!", ((CommandResult)result).Message);
}
public GenericCommandResult UpdateAccount(AlterarUsuarioCommand _command, [FromServices] AlterarUsuarioHandle _handle)
{
return((GenericCommandResult)_handle.Handle(_command));
}
public async Task <IActionResult> Alterar([FromBody] AlterarUsuarioCommand alterarUsuario)
{
return(await ExecuteCommand(alterarUsuario));
}
public void Alterar(AlterarUsuarioCommand command)
{
Nome = command.Nome;
}
public GenericCommandResult AlterarUsuario([FromServices] UsuarioHandler handler, [FromBody] AlterarUsuarioCommand usuario)
{
return((GenericCommandResult)handler.Handle(new AlterarUsuarioCommand
{
IdUsuario = usuario.IdUsuario,
Perfil = usuario.Perfil,
Ativo = usuario.Ativo
}));
}
public async Task <IResult> Handler(AlterarUsuarioCommand command)
{
command.Validate();
if (!command.Valid)
{
return(command.ValidationResult);
}
var usuario = await _repository.Usuario.GetUsuarioByIdAsync(command.Id);
if (usuario == null)
{
return(new CommandResult(false, "Usuário não encontrado", command.Notifications));
}
usuario = await _repository.Usuario.GetSetorByNameAndDiferentIdAsync(command.Id, command.Nome);
if (usuario != null)
{
return(new CommandResult(false, "Já existe um usuário com mesmo nome cadastrado", command.Notifications));
}
usuario = await _repository.Usuario.GetSetorByLoginAndDiferentIdAsync(command.Id, command.Login);
if (usuario != null)
{
return(new CommandResult(false, "Já existe um usuário com mesmo login cadastrado", command.Notifications));
}
usuario = await _repository.Usuario.GetUsuarioBySiglaAndDiferentIdAsync(command.Id, command.Sigla);
if (usuario != null)
{
return(new CommandResult(false, "Já existe um usuário com a mesma sigla cadastrada", command.Notifications));
}
var setor = await _repository.Setor.GetSetorByIdAsync(command.SetorId);
if (setor == null)
{
return(new CommandResult(false, "Setor não encontrado", command.Notifications));
}
var usuarioEntity = _mapper.Map <Usuario>(command);
usuarioEntity.Setor = setor;
if (string.IsNullOrWhiteSpace(command.Senha))
{
usuario = await _repository.Usuario.GetUsuarioByIdAsync(command.Id);
usuarioEntity.Senha = usuario.Senha;
}
else
{
var passwordEncrypted = _cryptographyService.Encrypt(usuarioEntity.Senha);
usuarioEntity.Senha = passwordEncrypted;
}
_repository.Usuario.Update(usuarioEntity);
await _repository.SaveAsync();
return(new CommandResult("Dados alterados com sucesso!"));
}
public ICommandResult AlterarUsuario(AlterarUsuarioCommand command, [FromServices] AlterarUsuarioCommandHandler handler)
{
command.IdUsuario = Guid.Parse(HttpContext.User.Claims.FirstOrDefault(c => c.Type == JwtRegisteredClaimNames.Jti).Value);
return((GenericCommandResult)handler.Handle(command));
}
