protected async Task <string> GetEncodedJwtAsync(AuthenticateUserCommand command, ClaimsIdentity identity)
{
if (identity == null)
{
return(string.Empty);
}
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.UniqueName, command.Email),
new Claim(JwtRegisteredClaimNames.NameId, command.Email),
new Claim(JwtRegisteredClaimNames.Email, command.Email),
new Claim(JwtRegisteredClaimNames.Sub, command.Email),
new Claim(JwtRegisteredClaimNames.Jti, await _tokenOptions.JtiGenerator()),
new Claim(JwtRegisteredClaimNames.Iat, ToUnixEpochDate(_tokenOptions.IssuedAt).ToString(), ClaimValueTypes.Integer64),
identity.FindFirst("AnyGym"),
identity.FindFirst("UserId")
};
var jwt = new JwtSecurityToken(
issuer: _tokenOptions.Issuer,
audience: _tokenOptions.Audience,
claims: claims.AsEnumerable(),
notBefore: _tokenOptions.NotBefore,
expires: _tokenOptions.Expiration,
signingCredentials: _tokenOptions.SigningCredentials);
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
return(encodedJwt);
}
public async Task <IActionResult> Post([FromForm] AuthenticateUserCommand command)
{
if (command == null)
{
return(await Response(null, new List <Notification> {
new Notification("User", "Usuário e/ou senha inválida!")
}));
}
var identity = await GetClaims(command);
if (identity == null)
{
return(await Response(null, new List <Notification> {
new Notification("User", "Usuário e/ou senha inválida!")
}));
}
var claims = new[] {
new Claim(JwtRegisteredClaimNames.UniqueName, command.username),
new Claim(JwtRegisteredClaimNames.NameId, command.username),
new Claim(JwtRegisteredClaimNames.Email, command.username),
new Claim(JwtRegisteredClaimNames.Sub, command.username),
new Claim(JwtRegisteredClaimNames.Jti, await _tokenOptions.JtiGenerator()),
new Claim(JwtRegisteredClaimNames.Iat, ToUnixEpochDate(_tokenOptions.IssuedAt).ToString(), ClaimValueTypes.Integer64),
identity.FindFirst("ModernStore"),
identity.FindFirst("Teste")
};
//User.Identity.Name
//User.Claims
var jwt = new JwtSecurityToken(
issuer: _tokenOptions.Issuer,
audience: _tokenOptions.Audience,
claims: claims.AsEnumerable(),
notBefore: _tokenOptions.NotBefore,
expires: _tokenOptions.Expiration,
signingCredentials: _tokenOptions.SigningCredentials
);
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
var response = new
{
token = encodedJwt,
expires = (int)_tokenOptions.ValidFor.TotalSeconds,
user = new
{
id = _customer.Id,
name = $"{_customer.FirstName} {_customer.LastName}",
email = _customer.Email.Address,
username = _customer.User.Username
}
};
var json = JsonConvert.SerializeObject(response, _serializerSettings);
return(new OkObjectResult(response));
}
public async Task <IActionResult> Post([FromForm] AuthenticateUserCommand command)
{
if (command == null)
{
return(await Response(null, new List <Notification> {
new Notification("User", "Usuário ou senha inválidos")
}));
}
var identity = await GetClaims(command);
if (identity == null)
{
return(await Response(null, new List <Notification> {
new Notification("User", "Usuário ou senha inválidos")
}));
}
var claims = new List <Claim>()
{
new Claim(JwtRegisteredClaimNames.UniqueName, command.Username),
new Claim(JwtRegisteredClaimNames.NameId, command.Username),
new Claim(JwtRegisteredClaimNames.Email, command.Username),
new Claim(JwtRegisteredClaimNames.Sub, command.Username),
new Claim(JwtRegisteredClaimNames.Jti, await _tokenOptions.JtiGenerator()),
new Claim(JwtRegisteredClaimNames.Iat, ToUnixEpochDate(_tokenOptions.IssuedAt).ToString(), ClaimValueTypes.Integer64),
};
claims.AddRange(identity.Claims);
var jwt = new JwtSecurityToken(
issuer: _tokenOptions.Issuer,
audience: _tokenOptions.Audience,
claims: claims.AsEnumerable(),
notBefore: _tokenOptions.NotBefore,
expires: _tokenOptions.Expiration,
signingCredentials: _tokenOptions.SigningCredentials);
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
var response = new
{
access_token = encodedJwt,
expires = (int)_tokenOptions.ValidFor.TotalSeconds,
user = new
{
id = _customer.Id,
name = _customer.Name.ToString(),
email = _customer.Email.Address,
username = _customer.User.Username
}
};
return(new OkObjectResult(response));
}
public async Task <IActionResult> Login([FromForm] LoginCommand command)
{
if (command == null)
{
return(await CreateResponse(null, new[] { new Notification("User", "Invalid user name or password.") }));
}
var user = _userRepository.GetByEmail(command.Username);
if (user == null || !user.Authenticate(command.Username, command.Password))
{
return(await CreateResponse(null, new[] { new Notification("User", "Invalid user name or password.") }));
}
var identity = await GetClaims(user);
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.UniqueName, user.Email),
new Claim(JwtRegisteredClaimNames.NameId, user.Email),
new Claim(JwtRegisteredClaimNames.Email, user.Email),
new Claim(JwtRegisteredClaimNames.Sub, user.Email),
new Claim(JwtRegisteredClaimNames.Jti, await _tokenOptions.JtiGenerator()),
new Claim(JwtRegisteredClaimNames.Iat, ToUnixEpochDate(_tokenOptions.IssuedAt).ToString(), ClaimValueTypes.Integer64),
identity.FindFirst("NorthWind")
};
var jwt = new JwtSecurityToken(
issuer: _tokenOptions.Issuer,
audience: _tokenOptions.Audience,
claims: claims.AsEnumerable(),
notBefore: _tokenOptions.NotBefore,
expires: _tokenOptions.Expiration,
signingCredentials: _tokenOptions.SigningCredentials);
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
var response = new
{
token = encodedJwt,
expires = (int)_tokenOptions.ValidFor.TotalSeconds,
user = new
{
id = user.Id,
name = $"{user.FirstName} {user.LastName}",
email = user.Email,
username = user.Email
}
};
var json = JsonConvert.SerializeObject(response, _serializerSettings);
return(new OkObjectResult(json));
}
public async Task <IActionResult> Login([FromBody] LoginCommand command)
{
if (command == null)
{
return(BadRequest());
}
var identity = await GetClaims(command);
if (identity == null)
{
return(BadRequest(new { Messages = new List <Notification> {
new Notification("User", "User not found.")
} }));
}
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.UniqueName, command.Email),
new Claim(JwtRegisteredClaimNames.NameId, command.Email),
new Claim(JwtRegisteredClaimNames.Email, command.Email),
new Claim(JwtRegisteredClaimNames.Sub, command.Email),
new Claim(JwtRegisteredClaimNames.Jti, await _tokenOptions.JtiGenerator()),
new Claim(JwtRegisteredClaimNames.Iat, ToUnixEpochDate(_tokenOptions.IssuedAt).ToString(), ClaimValueTypes.Integer64),
identity.FindFirst("Meetup")
};
var jwt = new JwtSecurityToken(
issuer: _tokenOptions.Issuer,
audience: _tokenOptions.Audience,
claims: claims.AsEnumerable(),
notBefore: _tokenOptions.NotBefore,
expires: _tokenOptions.Expiration,
signingCredentials: _tokenOptions.SigningCredentials);
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
var response = new
{
token = encodedJwt,
expires = (int)_tokenOptions.ValidFor.TotalSeconds,
user = new
{
id = _user.Id,
name = _user.Name,
email = _user.Email,
}
};
var json = JsonConvert.SerializeObject(response, _serializerSettings);
return(new OkObjectResult(json));
}
public async Task <IActionResult> Post([FromForm] AuthenticateUserCommand command)
{
if (command == null)
{
return(null);
}
var identity = await GetClaims(command);
if (identity == null)
{
return(Ok(new CommandResult(false, "Os seguites campos não estão preenchidos corretamente",
new Notification("Senha", "Não foi possivel válidar o usuario e senha"))));
}
var claims = new []
{
new Claim(JwtRegisteredClaimNames.UniqueName, command.UserName),
new Claim(JwtRegisteredClaimNames.NameId, command.UserName),
new Claim(JwtRegisteredClaimNames.Email, command.UserName),
new Claim(JwtRegisteredClaimNames.Sub, command.UserName),
new Claim(JwtRegisteredClaimNames.Jti, await _tokenOptions.JtiGenerator()),
new Claim(JwtRegisteredClaimNames.Iat, ToUnixEpochDate(_tokenOptions.IssuedAt).ToString(), ClaimValueTypes.Integer64),
identity.FindFirst("Apptest")
};
var jwt = new JwtSecurityToken(
issuer: _tokenOptions.Issuer,
audience: _tokenOptions.Audience,
claims: claims.AsEnumerable(),
notBefore: _tokenOptions.NotBefore,
expires: _tokenOptions.Expiration,
signingCredentials: _tokenOptions.SigningCredentials);
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
var response = new
{
token = encodedJwt,
expires_in = (int)_tokenOptions.ValidFor.TotalSeconds,
users = new
{
name = _customer.Name.ToString(),
email = _customer.Email
}
};
var json = JsonConvert.SerializeObject(response, _serializerSettings);
return(new OkObjectResult(json));
}
public async Task <IActionResult> Post([FromForm] AuthenticateUser form)
{
if (form == null)
{
return(await Response(null, "Usuário ou senha inválidos"));
}
var identity = await GetClaims(form.Username, form.Password);
if (identity == null)
{
return(await Response(null, "Usuário ou senha nao conferem"));
}
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.UniqueName, identity.Name),
new Claim(JwtRegisteredClaimNames.NameId, identity.Name),
new Claim(JwtRegisteredClaimNames.Email, string.Empty),
new Claim(JwtRegisteredClaimNames.Sub, form.Username),
new Claim(JwtRegisteredClaimNames.Jti, await _tokenOptions.JtiGenerator()),
new Claim(JwtRegisteredClaimNames.Iat, ToUnixEpochDate(_tokenOptions.IssuedAt).ToString(), ClaimValueTypes.Integer64),
identity.FindFirst("JWT_Example")
};
var jwt = new JwtSecurityToken(
issuer: _tokenOptions.Issuer,
audience: _tokenOptions.Audience,
claims: claims.AsEnumerable(),
notBefore: _tokenOptions.NotBefore,
expires: _tokenOptions.Expiration,
signingCredentials: _tokenOptions.SigningCredentials);
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
var response = new
{
token = encodedJwt,
expires = (int)_tokenOptions.ValidFor.TotalSeconds,
//expires = _tokenOptions.Expiration,
user = new
{
authenticated = identity.IsAuthenticated,
username = identity.Name
}
};
var json = JsonConvert.SerializeObject(response, _serializerSettings);
return(new OkObjectResult(json));
}
public async Task <IActionResult> Get([FromBody] UserViewModel applicationUser)
{
var userInfo = _userService.GetUserByName(applicationUser.UserName);
if (userInfo.Password != applicationUser.Password)
{
return(BadRequest("Invalid credentials"));
}
var identity = await GetClaimsIdentity(applicationUser);
if (identity == null)
{
return(BadRequest("Invalid credentials"));
}
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Sub, applicationUser.UserName),
new Claim(JwtRegisteredClaimNames.Jti, await _jwtOptions.JtiGenerator()),
new Claim(JwtRegisteredClaimNames.Iat,
ToUnixEpochDate(_jwtOptions.IssuedAt).ToString(),
ClaimValueTypes.Integer64),
identity.FindFirst("SuperAdmin")
};
// Create the JWT security token and encode it.
var jwt = new JwtSecurityToken(
issuer: _jwtOptions.Issuer,
audience: _jwtOptions.Audience,
claims: claims,
notBefore: _jwtOptions.NotBefore,
expires: _jwtOptions.Expiration,
signingCredentials: _jwtOptions.SigningCredentials);
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
// Serialize and return the response
var response = new
{
access_token = encodedJwt,
expires_in = (int)_jwtOptions.ValidFor.TotalSeconds
};
var json = JsonConvert.SerializeObject(response, _serializerSettings);
return(new OkObjectResult(json));
}
private static IEnumerable <Claim> GetClaims(TokenOptions tokenOptions)
{
yield return(new Claim(JwtRegisteredClaimNames.UniqueName, "usuario teste"));
yield return(new Claim(JwtRegisteredClaimNames.Email, "*****@*****.**"));
yield return(new Claim(JwtRegisteredClaimNames.Sub, Guid.NewGuid().ToString()));
yield return(new Claim(JwtRegisteredClaimNames.Jti, tokenOptions.JtiGenerator()));
yield return(new Claim(JwtRegisteredClaimNames.Iat, ToUnixEpochDate(tokenOptions.IssuedAt).ToString(), ClaimValueTypes.Integer64));
yield return(new Claim(ClaimTypes.Role, "pessoas-adicionar"));
yield return(new Claim(ClaimTypes.Role, "pessoas-editar"));
}
public async Task <IActionResult> Post([FromBody] AutenticarUsuarioComando comando)
{
var identity = await GetClaims(comando);
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Email, comando.Email),
new Claim(JwtRegisteredClaimNames.Jti, await _tokenOptions.JtiGenerator()),
new Claim(JwtRegisteredClaimNames.Iat, ToUnixEpochDate(_tokenOptions.IssuedAt).ToString(), ClaimValueTypes.Integer64),
identity.FindFirst("PontuaAe")
};
var jwt = new JwtSecurityToken(
issuer: _tokenOptions.Issuer,
audience: _tokenOptions.Audience,
claims: claims.AsEnumerable(),
notBefore: _tokenOptions.NotBefore,
expires: _tokenOptions.Expiration,
signingCredentials: _tokenOptions.SigningCredentials);
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
var response = new
{
token = encodedJwt,
expires = (int)_tokenOptions.ValidFor.TotalSeconds,
users = new
{
id = _usuario.ID,
email = comando.Email,
claimValue = _usuario.ClaimValue,
}
};
var json = JsonConvert.SerializeObject(response, _serializerSettings);
return(new OkObjectResult(json));
}
public async Task <IActionResult> PostUserAuthenticate([FromForm] AuthenticateUserCommand cmd)
{
if (cmd == null)
{
return
(await CreateResponse(new ObjectRequest().CreateObjectRequest("Usuario ou Senha Invalidos", false)));
}
ClaimsIdentity identity = await GetClaims(cmd);
if (identity == null)
{
return
(await CreateResponse(new ObjectRequest().CreateObjectRequest("Usuario ou Senha Invalidos", false)));
}
// criando um array de claims para podermos acessar no controller atraves do User.Identity.Name
var Claims = new[]
{
new Claim(JwtRegisteredClaimNames.UniqueName, cmd.Email),
new Claim(JwtRegisteredClaimNames.NameId, cmd.Email),
new Claim(JwtRegisteredClaimNames.Email, cmd.Email),
new Claim(JwtRegisteredClaimNames.Sub, cmd.Email),
new Claim(JwtRegisteredClaimNames.Jti, await _TokenOptions.JtiGenerator()),
new Claim(JwtRegisteredClaimNames.Iat, ToUnityEpochDate(_TokenOptions.IssuedAt).ToString(), ClaimValueTypes.Integer64),
identity.FindFirst("Lafan")
};
// Gerar o Json Web Token
var jwt = new JwtSecurityToken(
issuer: _TokenOptions.Issuer,
audience: _TokenOptions.Audience,
claims: Claims.AsEnumerable(),
notBefore: _TokenOptions.NotBefore,
expires: _TokenOptions.Expiration,
signingCredentials: _TokenOptions.SigningCredentials);
// codificar o token
var encondedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
// Gerar a Resposta
var response = new
{
access_token = encondedJwt,
expires_in = (int)_TokenOptions.ValidFor.TotalSeconds,
user = new
{
id = _UserAuthenticated.ID,
name = _UserAuthenticated.Name,
email = _UserAuthenticated.Email,
role = _UserAuthenticated.Profile.ToString()
}
};
// converter para Json
var json = JsonConvert.SerializeObject(response, _serializeSettings);
return(Ok(json));
}
public async Task <IActionResult> SignIn([FromBody] AuthenticateUserCommand command)
{
if (command == null)
{
return(await Response(null,
new List <Notification> {
new Notification("User", "Usuário ou senha inválidos")
}));
}
var identity = await GetClaims(command);
if (identity == null)
{
return(await Response(null,
new List <Notification> {
new Notification("User", "Usuário ou senha inválidos")
}));
}
var seconds = ToUnixEpochDate(_tokenOptions.IssuedAt);
if (command.KeepLoggedIn.GetValueOrDefault())
{
seconds *= 256;
}
var identityE = identity.FindFirst("Saas");
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.UniqueName, _user.Id.ToString()),
new Claim(JwtRegisteredClaimNames.NameId, _user.Name.FirstName),
new Claim(JwtRegisteredClaimNames.Email, _user.Email.Address),
new Claim(JwtRegisteredClaimNames.Sub, _user.Id.ToString()),
new Claim(JwtRegisteredClaimNames.Jti, await _tokenOptions.JtiGenerator()),
new Claim(JwtRegisteredClaimNames.Iat, seconds.ToString(), ClaimValueTypes.Integer64),
identityE
};
var jwt = new JwtSecurityToken(
_tokenOptions.Issuer,
_tokenOptions.Audience,
claims.AsEnumerable(),
_tokenOptions.NotBefore,
_tokenOptions.Expiration,
_tokenOptions.SigningCredentials);
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
var response = new
{
token = encodedJwt,
expires = (int)_tokenOptions.ValidFor.TotalSeconds,
user = new
{
id = _user.Id,
name = _user.ToString(),
email = _user.Email.Address
}
};
var json = JsonConvert.SerializeObject(response, _serializerSettings);
return(new OkObjectResult(json));
}
public ICommandResult Handle(AuthenticateUserCommand command)
{
if (command == null)
{
return(new CommandResult(false, new List <Notification> {
new Notification("User", "Usuário ou senha inválidos")
}));
}
var contract = new AuthenticateUserCommandContract(command);
if (contract.Contract.Invalid)
{
return(new CommandResult(false, contract.Contract.Notifications));
}
//Busca o Usuário no banco de dados
Usuario _usuario = _repository.Authenticate(command.CPF, command.Senha);
if (_usuario == null)
{
return(new CommandResult(false, new List <Notification> {
new Notification("User", "Usuário ou senha inválidos")
}));
}
var claims = new List <Claim>()
{
new Claim(JwtRegisteredClaimNames.UniqueName, command.CPF),
new Claim(JwtRegisteredClaimNames.NameId, command.CPF),
new Claim(JwtRegisteredClaimNames.Email, command.CPF),
new Claim(JwtRegisteredClaimNames.Sub, command.CPF),
new Claim(JwtRegisteredClaimNames.Jti, _tokenOptions.JtiGenerator()),
new Claim(JwtRegisteredClaimNames.Iat, ToUnixEpochDate(_tokenOptions.IssuedAt).ToString(), ClaimValueTypes.Integer64),
new Claim("Nome", _usuario.Nome),
new Claim("IdPessoa", _usuario.IdPessoa.ToString()),
new Claim("IdPessoaPai", _usuario.IdPessoaPai.ToString()),
};
var jwt = new JwtSecurityToken(
issuer: _tokenOptions.Issuer,
audience: _tokenOptions.Audience,
claims: claims.AsEnumerable(),
notBefore: _tokenOptions.NotBefore,
expires: _tokenOptions.Expiration,
signingCredentials: _tokenOptions.SigningCredentials);
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
var response = new
{
token = encodedJwt,
expires = (int)_tokenOptions.ValidFor.TotalSeconds,
user = new
{
id = _usuario.Id,
name = _usuario.Nome,
idPessoaPai = _usuario.IdPessoaPai,
idPessoa = _usuario.IdPessoa,
firstName = _usuario.FirstName,
imagem = _usuario.Imagem
}
};
return(new CommandResult(true, response));
}
public async Task <IActionResult> Post([FromForm] AuthenticateUserCommand command)
{
try
{
if (command == null)
{
return(await Response(null, new List <Notification> {
new Notification("User", "Usuário ou senha inválidos")
}));
}
var contract = new AuthenticateUserCommandContract(command);
if (contract.Contract.Invalid)
{
return(await Response(command, contract.Contract.Notifications));
}
var identity = await GetClaims(command);
if (identity == null)
{
return(await Response(null, new List <Notification> {
new Notification("User", "Usuário ou senha inválidos")
}));
}
var claims = new List <Claim>()
{
new Claim(JwtRegisteredClaimNames.UniqueName, command.CPF),
new Claim(JwtRegisteredClaimNames.NameId, command.CPF),
new Claim(JwtRegisteredClaimNames.Email, command.CPF),
new Claim(JwtRegisteredClaimNames.Sub, command.CPF),
new Claim(JwtRegisteredClaimNames.Jti, await _tokenOptions.JtiGenerator()),
new Claim(JwtRegisteredClaimNames.Iat, ToUnixEpochDate(_tokenOptions.IssuedAt).ToString(), ClaimValueTypes.Integer64),
identity.FindFirst("Nome"),
identity.FindFirst("IdPessoaPai"),
identity.FindFirst("IdPessoa")
};
//Adiciona um ou mais perfis
foreach (var item in identity.FindAll("Perfil"))
{
claims.Add(item);
}
var jwt = new JwtSecurityToken(
issuer: _tokenOptions.Issuer,
audience: _tokenOptions.Audience,
claims: claims.AsEnumerable(),
notBefore: _tokenOptions.NotBefore,
expires: _tokenOptions.Expiration,
signingCredentials: _tokenOptions.SigningCredentials);
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
var response = new
{
token = encodedJwt,
expires = (int)_tokenOptions.ValidFor.TotalSeconds,
user = new
{
id = _usuario.Id,
name = _usuario.Nome,
idPessoaPai = _usuario.IdPessoaPai,
idPessoa = _usuario.IdPessoa,
firstName = _usuario.FirstName,
imagem = _usuario.Imagem
}
};
var json = JsonConvert.SerializeObject(response);
return(new OkObjectResult(json));
}
catch (Exception ex)
{
return(await Response(null, new List <Notification> {
new Notification("User", "Usuário ou senha inválidos")
}));
}
}
public async Task <IActionResult> Autenticar([FromForm] AutenticarUsuarioEmpresaComando comando)
{
if (comando == null)
{
return(await Resposta(null, new List <Notification> {
new Notification("Usuario", "Usuário ou senha inválidos")
}));
}
var claimsIdentity = await BuscarClaims(comando);
if (claimsIdentity == null)
{
return(await Resposta(null, new List <Notification> {
new Notification("Usuario", "Usuário não encontrado.")
}));
}
if (!_usuarioEmpresa.Autenticado(comando.Senha))
{
return(await Resposta(null, new List <Notification> {
new Notification("Usuario", "Senha inválida.")
}));
}
var claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.UniqueName, _usuarioEmpresa.Id.ToString()),
new Claim(JwtRegisteredClaimNames.NameId, _usuarioEmpresa.Id.ToString()),
new Claim(JwtRegisteredClaimNames.Email, _usuarioEmpresa.Email.EnderecoEmail),
new Claim(JwtRegisteredClaimNames.Sub, _usuarioEmpresa.Id.ToString()),
new Claim(JwtRegisteredClaimNames.Jti, await _tokenOptions.JtiGenerator()),
new Claim(JwtRegisteredClaimNames.Iat, ConversorData.ConverterParaUnixEpochDate(_tokenOptions.IssuedAt).ToString(), ClaimValueTypes.Integer64),
};
foreach (Claim claim in claimsIdentity.Claims)
{
claims.Add(claim);
}
var jwt = new JwtSecurityToken(
issuer: _tokenOptions.Issuer,
audience: _tokenOptions.Audience,
claims: claims,
notBefore: _tokenOptions.NotBefore,
expires: _tokenOptions.Expiration,
signingCredentials: _tokenOptions.SigningCredentials);
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
var response = new
{
token = encodedJwt,
expires = (int)_tokenOptions.ValidFor.TotalSeconds,
user = new
{
usuarioId = _usuarioEmpresa.Id,
nome = _usuarioEmpresa.Nome.nome,
email = _usuarioEmpresa.Email.EnderecoEmail,
empresaId = _usuarioEmpresa.Empresa.Id,
nomeEmpresa = _usuarioEmpresa.Empresa.NomeEmpresa.nome
}
};
var json = JsonConvert.SerializeObject(response, _serializerSettings);
return(new OkObjectResult(json));
}
