public async Task <Result <UserPrivateDataDto> > UpdateRedisCache(string id, string email)
{
List <RefreshTokensModel> queryTokens = new List <RefreshTokensModel>();
RedisSecurityModel model = null;
var tokens = await _redisCache.GetSringValue(id);
if (!String.IsNullOrEmpty(tokens))
{
model = JsonConvert.DeserializeObject <RedisSecurityModel>(tokens);
if (model.Block)
{
return(_result.Create <UserPrivateDataDto>(true, _errors.NotAuthorized, null));
}
queryTokens = model.Tokens;
}
else
{
model = new RedisSecurityModel();
}
var refreshToken = _crypto.GetRandomNumber();
var RefreshTokenHashed = _crypto.GetStringSha256Hash(refreshToken + _settings.SecretKey);
createRefreshToken(id, queryTokens, RefreshTokenHashed);
model.Tokens = queryTokens;
var jsonString = JsonConvert.SerializeObject(model);
await _redisCache.SetStringValue(id, jsonString);
var dto = new UserPrivateDataDto();
dto.Id = id;
dto.Email = email;
dto.Token = refreshToken;
dto.Scopes = model.Scopes;
dto.Tenants = model.Tenants;
dto.ValidEmail = model.ValidEmail;
return(_result.Create(true, "", dto));
}
private async Task <Result <UserPrivateDataModel> > ValidRefreshToken(string token, string refreshToken)
{
var principal = _tokens.ValidateToken(token, false);
var id = principal.FindFirst(ClaimTypes.NameIdentifier).Value;
List <RefreshTokensModel> queryToken = null;
UserPrivateDataModel model = null;
RedisSecurityModel modelRedis = null;
var block = false;
if (!_settings.RedisCacheSecurity)
{
var result = await _services.GetSecrets(id);
if (!result.Success)
{
return(_result.Create <UserPrivateDataModel>(false, result.Message, null));
}
block = result.Value.Block;
queryToken = result.Value.RefreshTokens;
model = result.Value;
}
else
{
var email = principal.FindFirst(ClaimTypes.Email).Value;
var tokens = await _redisCache.GetSringValue(id);
if (String.IsNullOrEmpty(tokens))
{
return(_result.Create <UserPrivateDataModel>(false, _errors.NotAuthorized, null));
}
modelRedis = JsonConvert.DeserializeObject <RedisSecurityModel>(tokens);
block = modelRedis.Block;
queryToken = modelRedis.Tokens;
model = new UserPrivateDataModel();
model.id = id;
model.Email = email;
model.Scopes = modelRedis.Scopes;
model.Tenants = modelRedis.Tenants;
model.ValidEmail = modelRedis.ValidEmail;
}
var coderefreshToken = _crypto.GetStringSha256Hash(refreshToken + _settings.SecretKey);
var idx = queryToken.FindIndex((e) => e.Token == coderefreshToken);
if (idx < 0)
{
return(_result.Create <UserPrivateDataModel>(false, _errors.NotAuthorized, null));
}
else
{
queryToken.RemoveAt(idx);
if (!_settings.RedisCacheSecurity)
{
model.RefreshTokens = queryToken;
await _services.Update(model);
}
else
{
modelRedis.Tokens = queryToken;
var jsonString = JsonConvert.SerializeObject(modelRedis);
await _redisCache.SetStringValue(model.id, jsonString);
model.RefreshTokens = queryToken;
}
}
if (block)
{
return(_result.Create <UserPrivateDataModel>(false, _errors.NotAuthorized, null));
}
return(_result.Create(true, "", model));
}
