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)); }