public static bool ValidaToken(string tokenPass, int Acao, int idAux)
{
Token token = TokenDAO.GetAll().Where(x => x.GuidSec == tokenPass).FirstOrDefault();
try
{
if (token != null || token.ID != 0)
{
if (token.DataExpiracao > DateTime.Now)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}catch (Exception e)
{
return(false);
}
}
public ActionResult RequestPassword([FromBody] int id)
{
try
{
User user = null;
using (var userDAO = new UserDAO())
user = userDAO.Get(id);
Token token = new Token(user);
var emurbMail = new SystemMail(_smtp, _port, _login, _password);
if (user != null && emurbMail.SendNewPasswordMail(Request, token))
{
using (var tokenDAO = new TokenDAO())
tokenDAO.Add(token);
return(StatusCode(200, new { Message = "Enviado" }));
}
return(StatusCode(424, new { Message = "Erro ao gerar Token" }));
}
catch (Exception ex)
{
return(StatusCode(500, new { Message = "Houve um erro ao enviar o token para o email deste usuário" }));
}
}
public async Task GetExpired_Should_Succeed()
{
var expiredTokenA = await TokenDAO.Create(DbConnection, "description", DateTimeOffset.MinValue);
var expiredTokenB = await TokenDAO.Create(DbConnection, "description", DateTimeOffset.MinValue);
var expiredTokenC = await TokenDAO.Create(DbConnection, "description", DateTimeOffset.MinValue);
var expiredTokenD = await TokenDAO.Create(DbConnection, "description", DateTimeOffset.MinValue);
var notExpiredTokenA = await TokenDAO.Create(DbConnection, "description", DateTimeOffset.MaxValue);
var notExpiredTokenB = await TokenDAO.Create(DbConnection, "description", DateTimeOffset.MaxValue);
var expiredTokens = new List <string> {
expiredTokenA, expiredTokenB, expiredTokenC, expiredTokenD
};
var expiredPage1 = await TokenDAO.GetExpired(DbConnection, "0", 3);
Assert.Equal(expiredPage1.Count, 3);
foreach (var expiredToken in expiredPage1)
{
Assert.Contains(expiredToken, expiredTokens);
}
var expiredPage2 = await TokenDAO.GetExpired(DbConnection, expiredPage1[2], 3);
Assert.Equal(expiredPage2.Count, 1);
Assert.Contains(expiredPage2[0], expiredTokens);
}
public ActionResult SetPassword(string token, [FromBody] string password)
{
try
{
using (var tokenDAO = new TokenDAO())
{
var validToken = tokenDAO.GetByHash(token);
if (validToken != null && !string.IsNullOrEmpty(password))
{
using (var userDAO = new UserDAO())
if (userDAO.SetPassword(validToken.User.Id, password))
{
tokenDAO.Remove(validToken.Code);
}
return(StatusCode(202, new { Message = "Senha definida" }));
}
return(StatusCode(406, new { Message = "Token inválido" }));
}
}
catch (Exception ex)
{
return(StatusCode(500, new { Message = "Falha ao definir senha" }));
}
}
public Token getByID(String token_id)
{
Token token = new TokenDAO().getByToken(token_id); //throws Throws NoRecordException
//customer opvragen en in token plaatsen
token.customer = new CustomerService().getByID(token.customer.customer_id.ToString()); //throws Throws NoRecordException || DALException
return(token);
}
public IObservable <string> GetExpired()
{
var pagingStream = AsyncEnumerable.ToObservable <string, string>(
"0",
page => page.Count == 0,
page => page.Count > 0 ? page[page.Count - 1] : "0",
async(floor) => await TokenDAO.GetExpired(DbConnection, floor, 500)
);
return(pagingStream);
}
public async Task CreateToken_WithExpiration_Should_Succeed()
{
DateTimeOffset now = DateTimeOffset.Now;
var token = await TokenDAO.Create(DbConnection, "description", now);
Assert.NotNull(token);
var fullToken = await TokenDAO.GetById(DbConnection, token);
Assert.Equal(token, fullToken.ID);
Assert.Equal(now.ToUnixTimeMilliseconds(), fullToken.ExpiresAt);
}
public async Task CreateToken_WithNullExpiration_Should_Succeed()
{
var token = await TokenDAO.Create(DbConnection, "description", null);
Assert.NotNull(token);
var fullToken = await TokenDAO.GetById(DbConnection, token);
Assert.Equal(token, fullToken.ID);
Assert.NotNull(fullToken.CreatedAt);
Assert.Null(fullToken.ExpiresAt);
Assert.Null(fullToken.RevokedAt);
}
public ActionResult GetToken(string token)
{
try
{
Token validToken;
using (var tokenDAO = new TokenDAO())
validToken = tokenDAO.GetByHash(token);
return((validToken != null) ? StatusCode(200, validToken) : StatusCode(406, new { Message = "Token inválido" }));
}
catch (Exception ex)
{
return(StatusCode(500, new { Message = "Falha ao obter token" }));
}
}
public async Task <bool> Exists(string token)
{
var found = await TokenDAO.GetById(DbConnection, token);
if (found == null)
{
return(false);
}
if (found.ExpiresAt != null && found.ExpiresAt < DateTimeOffset.Now.ToUnixTimeMilliseconds())
{
return(false);
}
return(true);
}
public async Task <string> Lookup(string token)
{
var found = await TokenDAO.GetById(DbConnection, token);
if (found == null)
{
return(string.Empty);
}
if (found.ExpiresAt != null && found.ExpiresAt < DateTimeOffset.Now.ToUnixTimeMilliseconds())
{
return(string.Empty);
}
return(found.ID);
}
public async Task InvalidateToken_Should_Succeed()
{
var token = await TokenDAO.Create(DbConnection, "description", null);
Assert.NotNull(token);
var fullToken = await TokenDAO.GetById(DbConnection, token);
Assert.Null(fullToken.ExpiresAt);
await TokenDAO.Invalidate(DbConnection, token);
fullToken = await TokenDAO.GetById(DbConnection, token);
Assert.NotNull(fullToken.RevokedAt);
}
public ActionResult Add([FromBody] User user)
{
try
{
User existingUser = null;
using (var userDAO = new UserDAO())
{
existingUser = userDAO.GetByEmail(user.Email);
if (existingUser != null)
{
user.Id = existingUser.Id;
}
else
{
user.Id = userDAO.Add(user);
}
}
if (user.Id != 0)
{
Token token = new Token(user);
var emurbMail = new SystemMail(_smtp, _port, _login, _password);
if (emurbMail.SendNewPasswordMail(Request, token))
{
using (var tokenDAO = new TokenDAO())
tokenDAO.Add(token);
return(StatusCode(201, new {
Message = (existingUser != null) ? "Usuário já cadastrado, email reenviado com sucesso" : "Adicionado com sucesso"
}));
}
return(StatusCode(424, new { Message = "Falha ao enviar email" }));
}
return(StatusCode(304, new { Message = "Não adicionado" }));
}
catch (Exception ex)
{
return(StatusCode(500, new { Message = "Falha" }));
}
}
public void Run()
{
var expiredIds = new List <string>(TokenStore.GetExpired().ToEnumerable());
var expiredTokens = TokenDAO.GetByIdBulk(connection, expiredIds).Result;
long expirationCutoff = new DateTimeOffset(DateTime.UtcNow, new TimeSpan(-EXPIRATION_WINDOW_DAYS, 0, 0)).ToUnixTimeMilliseconds();
foreach (var expiredToken in expiredTokens)
{
if (expiredToken.ExpiresAt > expirationCutoff)
{
continue;
}
Log.Info($"Removing expired token { expiredToken.ID }");
TokenDAO.Delete(connection, expiredToken.ID).Wait();
}
}
/// <summary>
/// 通过令牌获取用户，需要验证令牌的有效性
/// </summary>
/// <param name="token"></param>
/// <returns></returns>
public User ValidToken(string token)
{
User user = MemCache.Get(token) as User;
if (null != user)
{
return(user);
}
TokenDAO td = new TokenDAO();
Token t = td.GetByAccessToken(token);
if (null == t)
{
throw new Exception("数据令牌无效");
}
if (td.IsExpired(t))
{
throw new Exception("数据令牌已过期");
}
return(t.User);
}
public static string GerateTokenValido(Token guidpassado)
{
string GuidGerado = "";
bool seguranca = false;
GuidGerado = Guid.NewGuid().ToString();
guidpassado.GuidSec = GuidGerado;
//Token token = TokenDAO.GetAll().Where(x => x.GuidSec == guid).FirstOrDefault();
while (seguranca)
{
Token token = TokenDAO.GetAll().Where(x => x.GuidSec == GuidGerado).FirstOrDefault();
if (token != null || token.ID != 0)
{
GuidGerado = Guid.NewGuid().ToString();
}
else
{
break;
}
}
guidpassado.DataCriacao = DateTime.Now;
guidpassado.DateAlteracao = DateTime.Now;
guidpassado.DataExpiracao = DateTime.Now.AddHours(2);
if (guidpassado.idUsuario == 0 || guidpassado.idCliente == 0)
{
return("Não foi possivel gerar um Token valido");
}
else
{
TokenDAO.Save(guidpassado);
return(GuidGerado);
}
}
public List <Token_Web> ObterToken()
{
return(TokenDAO.ObterToken());
}
public async Task <string> Create(string description, DateTimeOffset?expiration)
{
return(await TokenDAO.Create(DbConnection, description, expiration));
}
public async Task Invalidate(string token)
{
await TokenDAO.Invalidate(DbConnection, token);
}
