public async Task <IActionResult> Register([FromBody] RegisterModel model)
{
if (!ModelState.IsValid)
{
return(Response(model));
}
IdentityUser user = new IdentityUser {
UserName = model.Input.Email, Email = model.Input.Email
};
IdentityResult result = await _userManager.CreateAsync(user, model.Input.Password);
if (result.Succeeded)
{
RegistrarOrganizadorCommand registroCommand = new RegistrarOrganizadorCommand(Guid.Parse(user.Id), Input.Nome, Input.Cpf, Input.Email);
_bus.SendCommand(registroCommand);
if (!OperacaoValida())
{
await _userManager.DeleteAsync(user);
return(Response(model));
}
_logger.LogInformation(1, "Usuário criado com sucesso");
return(Response(model));
}
AdicionarErrosIdentity(result);
return(Response(model));
}
public async Task<IActionResult> Register([FromBody] RegisterViewModel model, int version)
{
if (version == 2)
{
return Response(new { Message = "API V2 não disponível na versão 2." });
}
if (!ModelState.IsValid) return Response(model);
var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var registroCommand = new RegistrarOrganizadorCommand(Guid.Parse(user.Id), model.Nome, model.CPF, user.Email);
_bus.SendCommand(registroCommand);
if (OperacaoValida())
{
await _userManager.DeleteAsync(user);
return Response(model);
}
_logger.LogInformation(1, "Usuário criado com sucesso!");
var response = GerarTokenUsuario(new LoginViewModel {Email = model.Email, Password = model.Password});
return Response(response);
}
AdicionarErrosIdentity(result);
return Response(model);
}
public async Task <IActionResult> Registrar([FromBody] RegisterViewModel model)
{
if (!ModelState.IsValid)
{
NotificarErroModelInvalida();
return(Response(model));
}
var user = new ApplicationUser {
UserName = model.Nome, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var registroCommand = new RegistrarOrganizadorCommand(
Guid.Parse(user.Id), model.Nome, model.CPF, model.Email);
_bus.SendCommand(registroCommand);
// Validação no domínio
if (!OperacaoValida())
{
await _userManager.DeleteAsync(user);
return(Response(model));
}
_logger.LogInformation(1, "Usuário criado com sucesso");
return(Response(model));
}
AdicionaErrosIdentity(result);
return(Response(model));
}
public async Task <IActionResult> Register([FromBody] RegisterViewModel model, int version)
{
if (version == 2)
{
return(Response(new { Message = "API V2 não disponível" }));
}
if (!ModelState.IsValid)
{
return(Response(model));
}
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
#region register claims
IEnumerable <Claim> claims = new List <Claim>()
{
new Claim("Eventos", "Ler"),
new Claim("Eventos", "Gravar")
};
await _userManager.AddClaimsAsync(user, claims);
#endregion
var registerCommand = new RegistrarOrganizadorCommand(Guid.Parse(user.Id), model.Nome, model.CPF, user.Email);
_bus.SendCommands(registerCommand);
if (!OperacaoValida())
{
await _userManager.DeleteAsync(user);
return(Response(model));
}
_logger.LogInformation(1, "Usuario criado com sucesso!");
var response = GerarTokenUsuario(new LoginViewModel {
Email = model.Email, Password = model.Password
});
return(Response(response));
}
AdicionarErrosIdentity(result);
return(Response(model));
}
public async Task <IActionResult> Register([FromBody] RegisterViewModel model, int version)
{
// O código abaixo é só um exemplo, vc pode definir códigos diferentes conforme a versão
// colocando-os em métodos diferentes que serão chamados sempre do mesmo método Register
if (version == 2)
{
return(Response(new { Message = "API V2 não disponível " }));
}
// Não deu certo e o que vc mandou foi isto aqui (model)
if (!ModelState.IsValid)
{
return(Response(model));
}
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("Eventos", "Ler"));
await _userManager.AddClaimAsync(user, new Claim("Eventos", "Gravar"));
var registroCommand = new RegistrarOrganizadorCommand(Guid.Parse(user.Id), model.Nome, model.CPF, user.Email);
_mediator.EnviarComando(registroCommand);
// Se o organizador não for criado por algum motivo apaga também o usuário criado no Identity
if (!OperacaoValida())
{
await _userManager.DeleteAsync(user);
return(Response(model));
}
// O número 1 sou eu quem defino, posso definir números diferentes para mensagens diferentes
_logger.LogInformation(1, "Usuário criado com sucesso!");
var response = await GerarTokenUsuario(new LoginViewModel { Email = model.Email, Senha = model.Senha });
return(Response(response));
}
AdicionarErrosIdentity(result);
return(Response(model));
}
public async Task <IActionResult> Register([FromBody] RegisterViewModel model, int version)
{
if (!ModelState.IsValid)
{
return(Response(model));
}
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// Claims de permissão do usuário
await _userManager.AddClaimsAsync(user, new[]
{
new Claim("Eventos", "Consultar"),
new Claim("Eventos", "Gravar"),
new Claim("Eventos", "Excluir")
});
// Executando o papel da Camada de Application
var registroCommand = new RegistrarOrganizadorCommand(Guid.Parse(user.Id), model.Nome, model.CpfCnpj, model.Email);
_bus.SendCommand(registroCommand);
if (!OperacaoValida())
{
await _userManager.DeleteAsync(user);
return(Response(model));
}
_logger.LogInformation(1, "Usuário criado com sucesso");
// Usuário criado com sucesso
// Retorna o token para não precisar efetuar o login
var response = await GerarTokenUsuario(new LoginViewModel { Email = model.Email, Password = model.Password });
return(Response(response));
}
AdicionarErrosIdentity(result);
return(Response(model));
}
public async Task <IActionResult> Register([FromBody] RegisterViewModel model, int version)
{
if (version == 2)
{
return(Response(new { Message = "API V2 não disponível" }));
}
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("Eventos", "Ler"));
await _userManager.AddClaimAsync(user, new Claim("Eventos", "Gravar"));
var registroCommand = new RegistrarOrganizadorCommand(Guid.Parse(user.Id), model.Nome, model.CPF, user.Email);
await _mediator.EnviarComando(registroCommand);
if (!OperacaoValida())
{
await _userManager.DeleteAsync(user);
return(Response(model));
}
_logger.LogInformation(1, "Usuário criado com sucesso!");
return(Response(await GerarTokenUsuario(new LoginViewModel {
Email = model.Email, Senha = model.Senha
})));
}
AdicionarErrosIdentity(result);
return(Response(model));
}