public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { this.tokens.Add(new TokenInfo { ConsumerKey = request.ConsumerKey, Token = response.Token, Secret = response.TokenSecret }); this.requestTokens.Add(response.Token, false); }
/// <summary> /// Stores a newly generated unauthorized request token, secret, and optional /// application-specific parameters for later recall. /// </summary> /// <param name="request">The request message that resulted in the generation of a new unauthorized request token.</param> /// <param name="response">The response message that includes the unauthorized request token.</param> /// <exception cref="ArgumentException">Thrown if the consumer key is not registered, or a required parameter was not found in the parameters collection.</exception> /// <remarks> /// Request tokens stored by this method SHOULD NOT associate any user account with this token. /// It usually opens up security holes in your application to do so. Instead, you associate a user /// account with access tokens (not request tokens) in the <see cref="ExpireRequestTokenAndStoreNewAccessToken"/> /// method. /// </remarks> public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { using (var db = new DbManager(_dbId)) { db.ExecuteNonQuery(new SqlInsert(TOKEN_TABLE, true).InColumnValue("token", response.Token).InColumnValue("token_secret", response.TokenSecret).InColumnValue("request_token",true)); } }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { var dictionary = LoadJson(); dictionary[response.Token] = response.TokenSecret; SaveJson(dictionary); }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { if (request == null) { throw new ArgumentNullException("request"); } if (response == null) { throw new ArgumentNullException("response"); } var user = _context.Users.Where(x => x.Id == _requestingUserId).First(); var data = new OAuthData { Token = response.Token, Secret = response.TokenSecret, TokenType = TokenType.RequestToken, TokenProvider = _tokenProvider, LinkedInUsers = new List <User> { user } }; _context.OAuthData.Add(data); _context.SaveChanges(); }
/// <summary> /// Stores a newly generated unauthorized request token, secret, and optional /// application-specific parameters for later recall. /// </summary> /// <param name="request">The request message that resulted in the generation of a new unauthorized request token.</param> /// <param name="response">The response message that includes the unauthorized request token.</param> /// <exception cref="ArgumentException">Thrown if the consumer key is not registered, or a required parameter was not found in the parameters collection.</exception> /// <remarks> /// Request tokens stored by this method SHOULD NOT associate any user account with this token. /// It usually opens up security holes in your application to do so. Instead, you associate a user /// account with access tokens (not request tokens) in the <see cref="ExpireRequestTokenAndStoreNewAccessToken"/> /// method. /// </remarks> public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { Consumer consumer; try { consumer = Database.DataContext.Consumers.First(c => c.ConsumerKey == request.ConsumerKey); } catch (InvalidOperationException) { throw new ArgumentOutOfRangeException(); } var token = new IssuedRequestToken { Callback = request.Callback, Consumer = consumer, Token = response.Token, TokenSecret = response.TokenSecret, }; string scope; if (request.ExtraData.TryGetValue("scope", out scope)) { token.Scope = scope; } Database.DataContext.AddToIssuedTokens(token); Database.DataContext.SaveChanges(); }
/// <summary> /// Stores a newly generated unauthorized request token, secret, and optional /// application-specific parameters for later recall. /// </summary> /// <param name="request">The request message that resulted in the generation of a new unauthorized request token.</param> /// <param name="response">The response message that includes the unauthorized request token.</param> /// <exception cref="ArgumentException">Thrown if the consumer key is not registered, or a required parameter was not found in the parameters collection.</exception> /// <remarks> /// Request tokens stored by this method SHOULD NOT associate any user account with this token. /// It usually opens up security holes in your application to do so. Instead, you associate a user /// account with access tokens (not request tokens) in the <see cref="ExpireRequestTokenAndStoreNewAccessToken"/> /// method. /// </remarks> public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { using (var db = new DbManager(_dbId)) { db.ExecuteNonQuery(new SqlInsert(TOKEN_TABLE, true).InColumnValue("token", response.Token).InColumnValue("token_secret", response.TokenSecret).InColumnValue("request_token", true)); } }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { StoreTokenData(new OAuthToken { Id = response.Token, SecretToken = response.TokenSecret, TokenType = TokenType.RequestToken }); _documentSession.SaveChanges(); }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { RequestScopedTokenMessage scopedRequest = (RequestScopedTokenMessage)request; var consumer = Global.DataContext.OAuthConsumers.Single(consumerRow => consumerRow.ConsumerKey == request.ConsumerKey); string scope = scopedRequest.Scope; OAuthToken newToken = new OAuthToken { OAuthConsumer = consumer, Token = response.Token, TokenSecret = response.TokenSecret, IssueDate = DateTime.UtcNow, Scope = scope, }; Global.DataContext.OAuthTokens.InsertOnSubmit(newToken); Global.DataContext.SubmitChanges(); }
/// <summary> </summary> public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { RequestScopedTokenMessage scopedRequest = (RequestScopedTokenMessage)request; var consumer = GlobalApplication.Consumers.Single(consumerRow => consumerRow.Key == request.ConsumerKey); string scope = scopedRequest.Scope; OAuthToken newToken = new OAuthToken { Consumer = consumer, Token = response.Token, TokenSecret = response.TokenSecret, IssueDate = DateTime.UtcNow, Scope = scope, }; GlobalApplication.AuthTokens.Add(newToken); }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { RequestScopedTokenMessage scopedRequest = (RequestScopedTokenMessage)request; var consumer = Global.DataContext.OAuthConsumers.Single(consumerRow => consumerRow.ConsumerKey == request.ConsumerKey); string scope = scopedRequest.Scope; OAuthToken newToken = new OAuthToken { OAuthConsumer = consumer, Token = response.Token, TokenSecret = response.TokenSecret, IssueDate = DateTime.UtcNow, Scope = scope, }; Global.DataContext.OAuthTokens.InsertOnSubmit(newToken); Global.DataContext.SubmitChanges(); }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { if ((request != null) && (response != null)) { string callback = string.Empty; if (request.Callback != null) { callback = request.Callback.AbsoluteUri; } using (OAuthTokenTableAdapter adapter = new OAuthTokenTableAdapter()) { adapter.Insert(Guid.NewGuid(), response.Token, response.TokenSecret, (int)OAuthTokenType.UnauthorizedRequestToken , GetConsumerId(request.ConsumerKey), ((IMessage)request).Version.ToString(), string.Empty, null, string.Empty, callback, DateTime.UtcNow, null, null, null); } } }
/// <summary> /// Stores a newly generated unauthorized request token, secret, and optional /// application-specific parameters for later recall. /// </summary> /// <param name="request">The request message that resulted in the generation of a new unauthorized request token.</param> /// <param name="response">The response message that includes the unauthorized request token.</param> /// <exception cref="ArgumentException">Thrown if the consumer key is not registered, or a required parameter was not found in the parameters collection.</exception> /// <remarks> /// Request tokens stored by this method SHOULD NOT associate any user account with this token. /// It usually opens up security holes in your application to do so. Instead, you associate a user /// account with access tokens (not request tokens) in the <see cref="ExpireRequestTokenAndStoreNewAccessToken"/> /// method. /// </remarks> public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { Consumer consumer; try { consumer = Database.DataContext.Consumers.First(c => c.ConsumerKey == request.ConsumerKey); } catch (InvalidOperationException) { throw new ArgumentOutOfRangeException(); } var token = new IssuedRequestToken { Callback = request.Callback, Consumer = consumer, Token = response.Token, TokenSecret = response.TokenSecret, }; string scope; if (request.ExtraData.TryGetValue("scope", out scope)) { token.Scope = scope; } Database.DataContext.AddToIssuedTokens(token); Database.DataContext.SaveChanges(); }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { string requestTokenFixed = response.Token.Replace(' ', '+'); this.tokens.Add(requestTokenFixed, new TokenInfo { ConsumerKey = request.ConsumerKey, Token = response.Token, Secret = response.TokenSecret }); this.requestTokens.Add(requestTokenFixed, false); }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { _tokens[response.Token] = new Tuple <string, TokenType>(response.TokenSecret, TokenType.RequestToken); }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { _tokens[response.Token] = new Tuple<string, TokenType>(response.TokenSecret, TokenType.RequestToken); }
/// <summary> /// Stores a newly generated unauthorized request token, secret, and optional /// application-specific parameters for later recall. /// </summary> /// <param name="request">The request message that resulted in the generation of a new unauthorized request token.</param> /// <param name="response">The response message that includes the unauthorized request token.</param> /// <exception cref="ArgumentException">Thrown if the consumer key is not registered, or a required parameter was not found in the parameters collection.</exception> /// <remarks> /// Request tokens stored by this method SHOULD NOT associate any user account with this token. /// It usually opens up security holes in your application to do so. Instead, you associate a user /// account with access tokens (not request tokens) in the <see cref="ITokenManager.ExpireRequestTokenAndStoreNewAccessToken"/> /// method. /// </remarks> void ITokenManager.StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { Contract.Requires <ArgumentNullException>(request != null); Contract.Requires <ArgumentNullException>(response != null); throw new NotImplementedException(); }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { Debug.WriteLine("StoreNewRequestToken: " + response.Token); this.requestTokens[response.Token] = response.TokenSecret; }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { this.tokensAndSecrets[response.Token] = response.TokenSecret; }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { Debug.WriteLine("StoreNewRequestToken: " + response.Token); this.requestTokens[response.Token] = response.TokenSecret; }
/// <summary> /// Stores a newly generated unauthorized request token, secret, and optional /// application-specific parameters for later recall. /// </summary> /// <param name="request">The request message that resulted in the generation of a new unauthorized request token.</param> /// <param name="response">The response message that includes the unauthorized request token.</param> /// <exception cref="T:System.ArgumentException">Thrown if the consumer key is not registered, or a required parameter was not found in the parameters collection.</exception> public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { this.requestToken = response.Token; this.requestTokenSecret = response.TokenSecret; }
/// <summary> /// Stores a newly generated unauthorized request token, secret, and optional /// application-specific parameters for later recall. /// </summary> /// <param name="request">The request message that resulted in the generation of a new unauthorized request token.</param> /// <param name="response">The response message that includes the unauthorized request token.</param> /// <exception cref="ArgumentException">Thrown if the consumer key is not registered, or a required parameter was not found in the parameters collection.</exception> /// <remarks> /// Request tokens stored by this method SHOULD NOT associate any user account with this token. /// It usually opens up security holes in your application to do so. Instead, you associate a user /// account with access tokens (not request tokens) in the <see cref="ITokenManager.ExpireRequestTokenAndStoreNewAccessToken"/> /// method. /// </remarks> void ITokenManager.StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { Contract.Requires<ArgumentNullException>(request != null); Contract.Requires<ArgumentNullException>(response != null); throw new NotImplementedException(); }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { throw new NotImplementedException(); }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { _tokenManager.StoreTokenSecret(response.Token, response.TokenSecret); }
/// <summary> /// Stores a newly generated unauthorized request token, secret, and optional /// application-specific parameters for later recall. /// </summary> /// <param name="request">The request message that resulted in the generation of a new unauthorized request token.</param> /// <param name="response">The response message that includes the unauthorized request token.</param> /// <exception cref="ArgumentException">Thrown if the consumer key is not registered, or a required parameter was not found in the parameters collection.</exception> /// <remarks> /// Request tokens stored by this method SHOULD NOT associate any user account with this token. /// It usually opens up security holes in your application to do so. Instead, you associate a user /// account with access tokens (not request tokens) in the <see cref="ITokenManager.ExpireRequestTokenAndStoreNewAccessToken"/> /// method. /// </remarks> void ITokenManager.StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { Requires.NotNull(request, "request"); Requires.NotNull(response, "response"); throw new NotImplementedException(); }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { this.CreateToken(response.Token, response.TokenSecret, string.Empty); }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { this.tokens.Add(new TokenInfo { ConsumerKey = request.ConsumerKey, Token = response.Token, Secret = response.TokenSecret }); this.requestTokens.Add(response.Token, false); }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { this._tokensAndSecrets[response.Token] = response.TokenSecret; this._tokenTypes.Add(response.Token, TokenType.RequestToken); }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { // No-op }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { // This method should never be ca lled // TODO: Throw an exception here? }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { this.CreateToken(response.Token, response.TokenSecret, string.Empty); }
/// <summary> /// Stores a newly generated unauthorized request token, secret, and optional /// application-specific parameters for later recall. /// </summary> /// <param name="request">The request message that resulted in the generation of a new unauthorized request token.</param> /// <param name="response">The response message that includes the unauthorized request token.</param> /// <exception cref="ArgumentException">Thrown if the consumer key is not registered, or a required parameter was not found in the parameters collection.</exception> /// <exception cref="ArgumentNullException">Thrown if a parameter is null.</exception> /// <exception cref="Glipho.OAuth.OAuthException">Thrown if an error occurs while executing the requested command.</exception> /// <remarks> /// Request tokens stored by this method SHOULD NOT associate any user account with this token. /// It usually opens up security holes in your application to do so. Instead, you associate a user /// account with access tokens (not request tokens) in the <see cref="TokenManager.ExpireRequestTokenAndStoreNewAccessToken(string, string, string, string)"/> /// method. /// </remarks> public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { if (request == null) { throw new ArgumentNullException("request", "request is null"); } if (response == null) { throw new ArgumentNullException("response", "response is null"); } var consumer = this.consumers.Get(request.ConsumerKey); if (consumer == null) { throw new ArgumentException(string.Format("Consumer with key \"{0}\" does not exist.", request.ConsumerKey)); } string scope; request.ExtraData.TryGetValue("scope", out scope); var requestToken = new Database.RequestToken(request.Callback, consumer.Id, response.Token, response.TokenSecret, scope != null ? scope.Split(',').AsEnumerable() : null); this.issuedTokens.Create(requestToken); }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { this.RequestToken = response.Token; this.RequestTokenSecret = response.TokenSecret; }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { var dictionary = LoadJson(); dictionary[response.Token] = response.TokenSecret; SaveJson(dictionary); }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { throw new NotImplementedException(); }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { _userTokenStore.AccessToken = response.Token; _userTokenStore.AccessTokenSecret = response.TokenSecret; }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { // No-op }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { HttpContext.Current.Session[response.Token] = response.TokenSecret; }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { // This method should never be ca lled // TODO: Throw an exception here? }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { _secrets.Create(response.Token, response.TokenSecret); }
public void StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { this.tokensAndSecrets[response.Token] = response.TokenSecret; }
/// <summary> /// Stores a newly generated unauthorized request token, secret, and optional /// application-specific parameters for later recall. /// </summary> /// <param name="request">The request message that resulted in the generation of a new unauthorized request token.</param> /// <param name="response">The response message that includes the unauthorized request token.</param> /// <exception cref="ArgumentException">Thrown if the consumer key is not registered, or a required parameter was not found in the parameters collection.</exception> /// <remarks> /// Request tokens stored by this method SHOULD NOT associate any user account with this token. /// It usually opens up security holes in your application to do so. Instead, you associate a user /// account with access tokens (not request tokens) in the <see cref="ITokenManager.ExpireRequestTokenAndStoreNewAccessToken"/> /// method. /// </remarks> void ITokenManager.StoreNewRequestToken(UnauthorizedTokenRequest request, ITokenSecretContainingMessage response) { Requires.NotNull(request, "request"); Requires.NotNull(response, "response"); throw new NotImplementedException(); }