public object Autenticar(
[FromBody] AutenticarUsuarioRequest request,
[FromServices] SigningConfigurations signingConfigurations,
[FromServices] TokenConfigurations tokenConfigurations)
{
bool credenciaisValidas = false;
AutenticarUsuarioResponse response = _serviceUsuario.AutenticarUsuario(request);
credenciaisValidas = response != null;
if (credenciaisValidas)
{
// e o que fica dentro do token que vou pegar depois
ClaimsIdentity identity = new ClaimsIdentity(
new GenericIdentity(response.Id.ToString(), "Id"),
new[] {
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
//new Claim(JwtRegisteredClaimNames.UniqueName, response.Usuario)
new Claim("Usuario", JsonConvert.SerializeObject(response))
}
);
DateTime dataCriacao = DateTime.Now;
DateTime dataExpiracao = dataCriacao +
TimeSpan.FromSeconds(tokenConfigurations.Seconds);
var handler = new JwtSecurityTokenHandler();
// onde cria o token
var securityToken = handler.CreateToken(new SecurityTokenDescriptor
{
Issuer = tokenConfigurations.Issuer,
Audience = tokenConfigurations.Audience,
SigningCredentials = signingConfigurations.SigningCredentials,
Subject = identity,
NotBefore = dataCriacao,
Expires = dataExpiracao
});
var token = handler.WriteToken(securityToken);
// retorno para usuario
return(new
{
authenticated = true,
created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"),
expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"),
accessToken = token,
message = "OK",
PrimeiroNome = response.PrimeiroNome
});
}
else
{
return(new
{
authenticated = false,
_serviceUsuario.Notifications
});
}
}
public object Autenticar(
[FromBody] AutenticarUsuarioRequest request,
[FromServices] SigningConfigurations signingConfigurations,
[FromServices] TokenConfigurations tokenConfigurations
)
{
bool credenciaisValidas = false;
var response = _serviceUsuario.AutenticarUsuario(request);
credenciaisValidas = response != null;
if (credenciaisValidas)
{
ClaimsIdentity identity = new ClaimsIdentity(
new GenericIdentity(response.Id.ToString(), "id"),
new[]
{
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim("Usuario", JsonConvert.SerializeObject(response))
});
DateTime CreateDate = DateTime.Now;
DateTime ExpireDate = CreateDate + TimeSpan.FromSeconds(tokenConfigurations.Seconds);
var handler = new JwtSecurityTokenHandler();
var securityToken = handler.CreateToken(new SecurityTokenDescriptor
{
Issuer = tokenConfigurations.Issuer,
Audience = tokenConfigurations.Audience,
SigningCredentials = signingConfigurations.SigningCredentials,
Subject = identity,
NotBefore = CreateDate,
Expires = ExpireDate
});
var token = handler.WriteToken(securityToken);
return(new
{
authenticated = true,
created = CreateDate.ToString("yyyy-MM-dd HH:mm:ss"),
expiration = ExpireDate.ToString("yyyy-MM-dd HH:mm:ss"),
accesToken = token,
message = "OK",
primeiroNomeDoProprietario = response.PrimeiroNome
});
//return GenerateToken(
// credenciais.UserID, signingConfigurations,
// tokenConfigurations, cache);
}
else
{
return(new
{
authenticated = false,
message = "Falha ao autenticar"
});
}
}
public object Auntenticar(
[FromBody] AutenticarUsuarioRequest request,
[FromServices] SigningConfiguracao signingConfiguracao,
[FromServices] TokenConfiguracao tokenConfiguracao)
{
bool credenciaisValidas = false;
AutenticarUsuarioResponse response = _serviceUsuario.AutenticarUsuario(request);
credenciaisValidas = response != null;
if (credenciaisValidas)
{
ClaimsIdentity identity = new ClaimsIdentity(
new GenericIdentity(response.Id.ToString(), "Id"),
new[]
{
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
// captura a resposta "Id e nome" da api coloca em objecto e serializa em um Json para se ler depois de pegar o Token.
new Claim("Usuario", JsonConvert.SerializeObject(response))
});
// Controle de data de expiracao do Tken
DateTime dataCriacao = DateTime.Now;
DateTime dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfiguracao.Seconds);
var handler = new JwtSecurityTokenHandler();
var securityToken = handler.CreateToken(new SecurityTokenDescriptor
{
Issuer = tokenConfiguracao.Issuer,
Audience = tokenConfiguracao.Audience,
SigningCredentials = signingConfiguracao.SigningCredentials,
Subject = identity,
NotBefore = dataCriacao,
Expires = dataExpiracao
});
var token = handler.WriteToken(securityToken);
return(new
{
authenticated = true,
created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"),
expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"),
accessToken = token,
message = "OK",
primeiroNome = response.PrimeiroNome
});
}
// Credenciais Invalidas
else
{
return(new
{
authenticated = false,
_serviceUsuario.Notifications
});
}
}
public object Autenticar([FromBody] AutenticarUsuarioRequest request, [FromServices] SigningConfigurations signingConfigurations, [FromServices] TokenConfigurations tokenConfigurations)
{
bool credenciaisValidas = false;
AutenticarUsuarioResponse response = _serviceUsuario.AutenticarUsuario(request);
credenciaisValidas = response != null;
if (credenciaisValidas)
{
ClaimsIdentity identity = new ClaimsIdentity(new GenericIdentity(response.Id.ToString(), "Id"),
new[] {
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
//new Claim(JwtRegisteredClaimNames.UniqueName, response.Usuario)
new Claim("Usuario", JsonConvert.SerializeObject(response))
}
);
DateTime dataCriacao = DateTime.Now;
DateTime dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfigurations.Seconds);
var handler = new JwtSecurityTokenHandler();
var securityToken = handler.CreateToken(new SecurityTokenDescriptor
{
Issuer = tokenConfigurations.Issuer,
Audience = tokenConfigurations.Audience,
SigningCredentials = signingConfigurations.SigningCredentials,
Subject = identity,
NotBefore = dataCriacao,
Expires = dataExpiracao,
});
var token = handler.WriteToken(securityToken);
return(new
{
authenticated = true,
//created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"),
//expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"),
accessToken = token,
message = "OK",
Email = response.email,
Password = response.email
});
}
else
{
return(new
{
authenticated = false,
BadRequestObjectResult = BadRequest("Erro ao autenticar usuário.")
});
}
}
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
try
{
IServiceUsuario serviceUsuario = _container.Resolve <IServiceUsuario>();
AutenticarUsuarioRequest request = new AutenticarUsuarioRequest();
request.Email = context.UserName;
request.Senha = context.Password;
AutenticarUsuarioResponse response = serviceUsuario.AutenticarUsuario(request);
if (serviceUsuario.IsInvalid())
{
if (response == null)
{
context.SetError("invalid_grant", "Preencha um e-mail válido e uma senha com pelo menos 6 caracteres.");
return;
}
}
serviceUsuario.ClearNotifications();
if (response == null)
{
context.SetError("invalid_grant", "Usuario não encontrado!");
return;
}
var identity = new ClaimsIdentity(context.Options.AuthenticationType);
//Definindo as Claims
identity.AddClaim(new Claim("Usuario", JsonConvert.SerializeObject(response)));
var principal = new GenericPrincipal(identity, new string[] { });
Thread.CurrentPrincipal = principal;
context.Validated(identity);
}
catch (Exception ex)
{
context.SetError("invalid_grant", ex.Message);
return;
}
}
public async Task <IActionResult> Autenticar([FromBody] AutenticarUsuarioRequest request)
{
try
{
var response = _serviceUsuario.AutenticarUsuario(request);
if (response != null)
{
var token = _accessManager.GenerateToken(response);
return(await ResponseAsync(token, _serviceUsuario));
}
return(await ResponseAsync(response, _serviceUsuario));
}
catch (Exception e)
{
return(await ResponseExceptionAsync(e));
}
}
public UsuarioDto AutenticarUsuario(UsuarioDto usuario)
{
var usuarioAuth = new Usuario();
usuarioAuth.PrepararParaAutenticar(usuario.CEmail, usuario.CSenha);
var res = _serviceUsuario.AutenticarUsuario(usuarioAuth);
if (res == null)
{
return(null);
}
var resDto = (UsuarioDto)res;
return(resDto);
}
