public async Task <AutenticacaoResult> RegistrarUsuarioAsync(RegistrarUsuarioRequest request)
{
var registrarUsuarioCommand = new RegistrarUsuarioCommand
{
RegistrarUsuario = _mapper
.Map <RegistrarUsuarioModel>(request)
};
var autenticacaoResult = await _mediator
.Send(registrarUsuarioCommand);
if (!autenticacaoResult.Sucesso)
{
return(autenticacaoResult);
}
await _mediator.Publish(new UsuarioRegistradoEvent
{
UsuarioId = autenticacaoResult.Usuario.Id,
Nome = $"{request.Nome} {request.Sobrenome}",
Telefone = request.Telefone,
Email = request.Email
});
return(autenticacaoResult);
}
public RegistrarUsuarioService(RegistrarUsuarioCommand command, IUsuarioRepository repository) : base(command)
{
_command = command;
_repository = repository;
this.Run();
}
public GenericCommandResult Create([FromBody] RegistrarUsuarioCommand command, [FromServices] UsuarioHandler handler)
{
command.IdFirebase = HttpContext.User.Identities.FirstOrDefault().Claims.FirstOrDefault(c => c.Type.Contains("user_id")).Value;
command.Email = HttpContext.User.Identities.FirstOrDefault().Claims.FirstOrDefault(c => c.Type.Contains("email")).Value;
return((GenericCommandResult)handler.Handle(command));
}
public async Task <IActionResult> PostRegistrar(RegistrarUsuarioRequest request)
{
var command = new RegistrarUsuarioCommand(request.NombreDeUsuario, request.Contrasenia, request.Nombre, request.Apellido, request.Email);
await this.mediator.Send(command);
return(this.Ok());
}
public async Task <IActionResult> Cadastrar([FromBody] UsuarioRequestViewModel viewmodel)
{
RegistrarUsuarioCommand command = _mapper.Map <RegistrarUsuarioCommand>(viewmodel);
await _bus.EnviarComando(command);
ApplicationUser usuario = await _userManager.FindByEmailAsync(viewmodel.Email);
return(Response(_mapper.Map <UsuarioResponseViewModel>(usuario)));
}
public static void Map(InputModelToDomainCommand config)
{
config.CreateMap <RegistrarUsuarioInputModel, RegistrarUsuarioCommand>()
.ConstructUsing(x => RegistrarUsuarioCommand.Criar(
x.PrimeiroNome,
x.SegundoNome,
x.Email,
x.Senha));
}
public Task <HttpResponseMessage> Registrar([FromBody] RegistrarUsuarioCommand command)
{
try
{
return(CreateResponseMessageSuccess(_mediator.Send(command).Result));
}
catch (Exception)
{
return(CreateResponseMessageError(_mediator.Send(command).Result));
}
}
public void Dado_um_novo_usuario_sua_validacao_devera_falhar()
{
var command = new RegistrarUsuarioCommand();
command.Login = "";
command.Senha = "123456t";
var service = new RegistrarUsuarioService(command, new FakeUsuarioRepository());
Assert.True(service.HasNotifications());
}
private async Task <ResponseMessage> RegistrarUsuario(UsuarioRegistradoIntegrationEvent message)
{
var usuarioCommand = new RegistrarUsuarioCommand(message.Id, message.Nome, message.Email, message.Cpf);
ValidationResult sucesso;
using (var scope = _serviceProvider.CreateScope())
{
var mediator = scope.ServiceProvider.GetRequiredService <IMediatorHandler>();
sucesso = await mediator.EnviarComando(usuarioCommand);
}
return(new ResponseMessage(sucesso));
}
public Domain.Usuario.Models.Usuario Atualizar(RegistrarUsuarioCommand command)
{
var usuario = new Domain.Usuario.Models.Usuario(command.Nome, command.Email, command.Senha, command.Perfil);
if (_repository.UsuarioJaExiste(command.EmailNovo))
{
DomainEvent.Raise(new DomainNotification("RegistroExistente", "O E-mail já está registrado no sistema."));
}
usuario.Atualizar();
if (Commit())
{
_repository.Update(usuario);
//Raise Domain events here
return(usuario);
}
return(null);
}
public Domain.Usuario.Models.Usuario Registrar(RegistrarUsuarioCommand command)
{
var usuario = new Domain.Usuario.Models.Usuario(command.Nome, command.Email, command.Senha, command.Perfil);
if (_repository.UsuarioJaExiste(usuario.Email))
{
DomainEvent.Raise(new DomainNotification("RegistroExistente", "O E-mail já está registrado no sistema."));
}
usuario.Registrar();
if (Commit())
{
_repository.Add(usuario);
//disparar Domain events aqui
DomainEvent.Raise(new RegistrarUsuario(usuario));
return(usuario);
}
return(null);
}
public async Task <IActionResult> Register([FromBody] RegisterViewModel model, int version)
{
if (!ModelState.IsValid)
{
NotificarErroModelInvalida();
return(Response());
}
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Senha);
if (result.Succeeded)
{
await _userManager.AddClaimAsync(user, new Claim("Contas", "Visualizar"));
await _userManager.AddClaimAsync(user, new Claim("Contas", "Alterar"));
var registroCommand = new RegistrarUsuarioCommand(Guid.Parse(user.Id), model.Nome, model.Sobrenome, model.CPF, user.Email, model.DataNascimento);
await _mediator.EnviarComando(registroCommand);
if (!OperacaoValida())
{
await _userManager.DeleteAsync(user);
return(Response(model));
}
_logger.LogInformation(1, "Usuario criado com sucesso!");
var response = GerarTokenUsuario(new LoginViewModel {
Email = model.Email, Senha = model.Senha
});
return(Response(response));
}
AdicionarErrosIdentity(result);
return(Response(model));
}
public async Task Handle_AutenticacaoHandler_UsuarioRegistradoComSucesso()
{
var faker = new Faker("pt_BR");
var novaSenha = faker.Internet.Password();
var comando = new RegistrarUsuarioCommand
{
RegistrarUsuario = new RegistrarUsuarioModel
{
Nome = faker.Person.FirstName,
Sobrenome = faker.Person.LastName,
Email = faker.Person.Email,
Username = faker.Person.UserName,
Senha = novaSenha,
ConfirmacaoSenha = novaSenha
}
};
var authResult = await _mediator.Send(comando);
authResult.Mensagem.Should().Be(Dicionario.MS003);
authResult.Sucesso.Should().BeTrue();
authResult.Token.Should().NotBeNullOrEmpty();
authResult.Usuario.Email.Should().Be(comando.RegistrarUsuario.Email);
}
public async Task <AutenticacaoResult> Handle(RegistrarUsuarioCommand request, CancellationToken cancellationToken)
{
return(await _autenticacaoServico.RegistrarUsuarioAsync(request.RegistrarUsuario));
}
public async Task <HttpResponseMessage> RegistrarUsuario([FromBody] RegistrarUsuarioCommand command)
{
return(await Task.FromResult(Request.CreateResponse(HttpStatusCode.OK, _mediator.Send(command))));
}
public IActionResult Post([FromBody] RegistrarUsuarioCommand command)
{
var service = new RegistrarUsuarioService(command, _usuarioRepo);
return(ReturnResponse(service, new { message = "Usuário cadastrado com sucesso" }, null));
}
