private void UpdatePrivate(UserPrivateDataModel item)
{
item.TimeModified = DateTime.Now;
}
public async Task<Result<string>> BlockUser(UserPrivateDataModel model)
{
bool ok = false;
string message = "";
try
{
model.ExpirationBlock = DateTime.UtcNow.AddYears(100);
model.TimeModified = DateTime.Now;
var key = new PartitionKey(_partitionId);
await RepositoryContainer.ReplaceItemAsync<UserPrivateDataModel>(model, model.id, key,
new ItemRequestOptions { });
ok = true;
}
catch (CosmosException ex)
{
message = ex.Message;
}
catch (Exception ex)
{
message = ex.Message;
}
return _result.Create(ok, message, "");
}
public async Task<Result<string>> ChangePassword(string email, string password)
{
bool ok = false;
string message = "";
string id = "";
try
{
var queryOptions = new QueryRequestOptions
{
PartitionKey = new PartitionKey(_partitionId),
MaxItemCount = 1
};
UserPrivateDataModel model = null;
var isFound = false;
var query = $"select * from d where d.Email = '{email}'";
using (FeedIterator<UserPrivateDataModel> feedIterator = RepositoryContainer.GetItemQueryIterator<UserPrivateDataModel>(
query,
null,
queryOptions))
{
while (feedIterator.HasMoreResults)
{
foreach (var itemBack in await feedIterator.ReadNextAsync())
{
model = itemBack;
isFound = true;
break;
}
}
}
if (!isFound)
{
message = _errors.NotFound;
}
else
{
UpdatePrivateMetadata(model, email, password, true);
var key = new PartitionKey(_partitionId);
await RepositoryContainer.ReplaceItemAsync(model, model.id, key);
id = model.id;
ok = true;
}
}
catch (CosmosException ex)
{
message = ex.Message;
}
catch (Exception ex)
{
message = ex.Message;
}
return _result.Create(ok, message, id);
}
public async Task<Result<UserPrivateDataModel>> GetSecrets(string id)
{
bool ok = false;
string message = "";
UserPrivateDataModel model = null;
try
{
var queryOptions = new QueryRequestOptions
{
PartitionKey = new PartitionKey(_partitionId),
MaxItemCount = 1
};
var isFound = false;
var query = $"select * from d where d.id = '{id}'";
using (FeedIterator<UserPrivateDataModel> feedIterator = RepositoryContainer.GetItemQueryIterator<UserPrivateDataModel>(
query,
null,
queryOptions))
{
while (feedIterator.HasMoreResults)
{
foreach (var itemBack in await feedIterator.ReadNextAsync())
{
model = itemBack;
isFound = true;
break;
}
}
}
if (!isFound)
{
message = _errors.NotFound;
}
else
{
ok = true;
}
}
catch (CosmosException ex)
{
message = ex.Message;
}
catch (Exception ex)
{
message = ex.Message;
}
return _result.Create(ok, message, model);
}
private async Task <Result <LoginDto> > SocialSave(SocialModel modelSocial, HttpRequest request)
{
UserPrivateDataModel model = new UserPrivateDataModel();
var register = await _services.Register(modelSocial.id, modelSocial.Email, _crypto.GetRandomNumber(), true);
if (!register.Success)
{
if (register.Message != _errors.Found)
{
return(_result.Create <LoginDto>(false, register.Message, null));
}
else
{
var found = await _services.GetSecrets(register.Value);
if (!found.Success)
{
return(_result.Create <LoginDto>(false, found.Message, null));
}
if (found.Value.Block)
{
return(_result.Create <LoginDto>(true, _errors.NotAuthorized, null));
}
model.id = found.Value.id;
model.Email = found.Value.Email;
model.ValidEmail = found.Value.ValidEmail;
model.Scopes = found.Value.Scopes;
model.Tenants = found.Value.Tenants;
model.Block = found.Value.Block;
}
}
else
{
model.id = register.Value;
model.Email = modelSocial.Email;
model.ValidEmail = true;
model.Scopes = modelSocial.Scopes;
model.Tenants = modelSocial.Tenants;
await UpdateScopes(model.id, model.Scopes);
await UpdateTenants(model.id, model.Tenants);
}
var dataResult = GetToken(model);
var login = EndToken(request, _settingsTokens.CookieToken, _settingsSecrets.CookieTokenPath, dataResult.Value);
return(_result.Create <LoginDto>(true, "", login));
}
private Result <UserPrivateDataDto> GetToken(UserPrivateDataModel model)
{
var token = _tokens.CreateToken(model.id, model.Email, model.Scopes, model.Tenants);
var dto = new UserPrivateDataDto();
dto.Id = model.id;
dto.Email = model.Email;
dto.ValidEmail = model.ValidEmail;
dto.Token = token;
dto.Scopes = model.Scopes;
dto.Tenants = model.Tenants;
return(_result.Create(true, "", dto));
}
private void UpdatePrivateMetadata(UserPrivateDataModel item, string email, string password, bool isUpdate, bool validEmail = false)
{
if (!isUpdate)
{
item.Email = email;
item.TimeCreated = DateTime.Now;
item.PartitionId = _partitionId;
item.ValidEmail = validEmail;
}
else
{
item.TimeModified = DateTime.Now;
}
item.Password = _crypto.GetStringSha256Hash(email + password + _settings.SecretKey);
}
public async Task <Result <UserPrivateDataDto> > UpdateSecrets(UserPrivateDataModel model)
{
var refreshToken = _crypto.GetRandomNumber();
var RefreshTokenHashed = _crypto.GetStringSha256Hash(refreshToken + _settings.SecretKey);
createRefreshToken(model.id, model.RefreshTokens, RefreshTokenHashed);
var result = await _services.Update(model);
if (!result.Success)
{
return(_result.Create <UserPrivateDataDto>(false, result.Message, null));
}
var dto = new UserPrivateDataDto();
dto.Id = model.id;
dto.Email = model.Email;
dto.Token = refreshToken;
return(_result.Create(true, "", dto));
}
public async Task<Result<AdditionalModel>> GetAdditional(string id)
{
bool ok = false;
string message = "";
AdditionalModel result = new AdditionalModel();
try
{
var queryOptions = new QueryRequestOptions
{
PartitionKey = new PartitionKey(_partitionId),
MaxItemCount = 1
};
var key = new PartitionKey(_partitionId);
UserPrivateDataModel model = await RepositoryContainer.ReadItemAsync<UserPrivateDataModel>(id, key,
new ItemRequestOptions { });
if(model != null)
{
result.Scopes = model.Scopes;
result.Tenants = model.Tenants;
result.ValidEmail = model.ValidEmail;
result.Block = model.Block;
}
ok = true;
}
catch (CosmosException ex)
{
message = ex.Message;
}
catch (Exception ex)
{
message = ex.Message;
}
return _result.Create(ok, message, result);
}
public async Task<Result<string>> Register(string userid, string email, string password, bool validEmail = false)
{
bool ok = false;
string message = "";
string id = "";
try
{
var queryOptions = new QueryRequestOptions
{
PartitionKey = new PartitionKey(_partitionId),
MaxItemCount = 1
};
var isFound = false;
var query = $"select d.id, d.Email from d where d.Email = '{email}'";
using (FeedIterator<UserPrivateDataModel> feedIterator = RepositoryContainer.GetItemQueryIterator<UserPrivateDataModel>(
query,
null,
queryOptions))
{
while (feedIterator.HasMoreResults)
{
foreach (var item in await feedIterator.ReadNextAsync())
{
id = item.id;
isFound = true;
break;
}
}
}
if (isFound)
{
message = _errors.Found;
}
else
{
var item = new UserPrivateDataModel();
if (String.IsNullOrEmpty(userid))
{
item.id = Guid.NewGuid().ToString();
}
else
{
item.id = userid;
}
UpdatePrivateMetadata(item, email, password, false, validEmail);
var key = new PartitionKey(_partitionId);
await RepositoryContainer.CreateItemAsync<UserPrivateDataModel>(item, key,
new ItemRequestOptions { });
id = item.id;
ok = true;
}
}
catch (CosmosException ex)
{
message = ex.Message;
}
catch (Exception ex)
{
message = ex.Message;
}
return _result.Create(ok, message, id);
}
public async Task<Result<string>> ValidateRegisterEmail(string email)
{
bool ok = false;
string message = "";
UserPrivateDataModel item = null;
try
{
var queryOptions = new QueryRequestOptions
{
PartitionKey = new PartitionKey(_partitionId),
MaxItemCount = 1
};
var isFound = false;
var query = $"select * from d where d.Email = '{email}'";
using (FeedIterator<UserPrivateDataModel> feedIterator = RepositoryContainer.GetItemQueryIterator<UserPrivateDataModel>(
query,
null,
queryOptions))
{
while (feedIterator.HasMoreResults)
{
foreach (var itemBack in await feedIterator.ReadNextAsync())
{
item = itemBack;
isFound = true;
break;
}
}
}
if (!isFound)
{
message = _errors.NotFound;
}
else
{
item.ValidEmail = true;
UpdatePrivate(item);
var key = new PartitionKey(_partitionId);
await RepositoryContainer.ReplaceItemAsync<UserPrivateDataModel>(item, item.id, key,
new ItemRequestOptions { });
message = item.id;
ok = true;
}
}
catch (CosmosException ex)
{
message = ex.Message;
}
catch (Exception ex)
{
message = ex.Message;
}
return _result.Create(ok, message, message);
}
public async Task <Result <string> > BlockUser(UserPrivateDataModel model)
{
return(await _repository.BlockUser(model));
}
public async Task <Result <string> > Update(UserPrivateDataModel model)
{
return(await _repository.Update(model));
}
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));
}
