private async void InitializeTwitter(IOAuthCredentials credentials) { try { //IsBusy = true; //Message = "Logging into Twitter..."; MUST.TwitterService.Instance.Initialize(credentials.ConsumerKey, credentials.ConsumerSecret, credentials.CallbackUri); var user = await MUST.TwitterService.Instance.GetUserAsync(); UserName = user.ScreenName; UserImage = new Uri(user.ProfileImageUrl); //Message = $"Logged in as {user.ScreenName}"; //FetchTweets($"@{user.ScreenName}"); } catch (Exception ex) { //ShowMessage(ex.Message); } finally { //IsBusy = false; } }
public EndpointResolver(IUrlResolver urlResolver, IUrlSigner urlSigner, IOAuthCredentials oAuthCredentials, IApiUri apiUri) { _urlResolver = urlResolver; _urlSigner = urlSigner; _oAuthCredentials = oAuthCredentials; _apiUri = apiUri; }
public void Should_use_api_uri_provided_by_IApiUri_interface() { const string expectedApiUri = "http://api.7dizzle"; Given_a_urlresolver_that_returns_valid_xml(); var apiUri = A.Fake <IApiUri>(); A.CallTo(() => apiUri.Uri).Returns(expectedApiUri); IOAuthCredentials oAuthCredentials = EssentialDependencyCheck <IOAuthCredentials> .Instance; var endpointResolver = new RequestCoordinator(_httpClient, _urlSigner, oAuthCredentials, apiUri); var requestData = new RequestData { UriPath = "test", HttpMethod = "GET", Headers = new Dictionary <string, string>() }; endpointResolver.HitEndpoint(requestData); A.CallTo(() => apiUri.Uri).MustHaveHappened(Repeated.Exactly.Once); A.CallTo(() => _httpClient.Get( A <GetRequest> .That.Matches(x => x.Url.ToString().Contains(expectedApiUri)))) .MustHaveHappened(Repeated.Exactly.Once); }
private ITokenRateLimits RefreshCredentialsRateLimits(IOAuthCredentials credentials) { var tokenRateLimits = GetTokenRateLimitsFromTwitter(credentials); _rateLimitCache.RefreshEntry(credentials, tokenRateLimits); return(_rateLimitCache.GetTokenRateLimits(credentials)); }
public IOAuthCredentials GetCredentials() { if(_credentials == null) _credentials = CheckIfAssembliesContainOAuthClass(); return _credentials; }
public RequestCoordinator(IHttpClient httpClient, IUrlSigner urlSigner, IOAuthCredentials oAuthCredentials, IApiUri apiUri) { HttpClient = httpClient; _urlSigner = urlSigner; _oAuthCredentials = oAuthCredentials; _apiUri = apiUri; }
public static void UpdateStatus(string tweet, IOAuthCredentials credentials) { var singleUserAuthorizer = new SingleUserAuthorizer { Credentials = credentials }; var twitterCtx = new TwitterContext(singleUserAuthorizer); twitterCtx.UpdateStatus(tweet); }
public OAuthService(IApiUri apiUri, IOAuthCredentials credentials) { Uri = apiUri.Uri; SecureUri = apiUri.SecureUri; ConsumerKey = credentials.ConsumerKey; ConsumerSecret = credentials.ConsumerSecret; }
private void AssertAreCredentialsEquals(IOAuthCredentials credentials1, IOAuthCredentials credentials2) { Assert.AreEqual(credentials1.AccessToken, credentials2.AccessToken); Assert.AreEqual(credentials1.AccessTokenSecret, credentials2.AccessTokenSecret); Assert.AreEqual(credentials1.ConsumerKey, credentials2.ConsumerKey); Assert.AreEqual(credentials1.ConsumerSecret, credentials2.ConsumerSecret); }
public ITwitterQuery Create(string queryURL, HttpMethod httpMethod, IOAuthCredentials oAuthCredentials) { var twitterQuery = Create(queryURL, httpMethod); twitterQuery.OAuthCredentials = oAuthCredentials; return(twitterQuery); }
public ITwitterAuthentificationResponse Authentificate(IOAuthCredentials oAuthCredentials) { if (oAuthCredentials == null) { throw new ApplicationException("OAuth credentials are null"); } return(Authentificate(oAuthCredentials.ApiKey, oAuthCredentials.ApiSecret)); }
public void ExecuteOperationWithCredentials(IOAuthCredentials credentials, Action operation) { var initialCredentials = CurrentThreadCredentials; CurrentThreadCredentials = credentials; operation(); CurrentThreadCredentials = initialCredentials; }
public ITokenRateLimits GetCredentialsRateLimits(IOAuthCredentials credentials) { var savedCredentials = _credentialsAccessor.CurrentThreadCredentials; _credentialsAccessor.CurrentThreadCredentials = credentials; var rateLimits = GetCurrentCredentialsRateLimits(); _credentialsAccessor.CurrentThreadCredentials = savedCredentials; return rateLimits; }
public QueryAwaitingEventArgs( string query, ITokenRateLimit queryRateLimit, IOAuthCredentials oAuthCredentials) { _query = query; _queryRateLimit = queryRateLimit; _oAuthCredentials = oAuthCredentials; }
public ILoggedUser GetLoggedUser(IOAuthCredentials credentials) { var userDTO = _credentialsAccessor.ExecuteOperationWithCredentials(credentials, () => { return(_userFactoryQueryExecutor.GetLoggedUser()); }); return(GenerateLoggedUserFromDTO(userDTO)); }
private void InitData() { _loggedUserCredentials = A.Fake <IOAuthCredentials>(); _fakeCredentialsAccessor.CallsTo(x => x.CurrentThreadCredentials).Returns(_loggedUserCredentials); _loggedUser = CreateLoggedUser(); _currentCredentials = A.Fake <IOAuthCredentials>(); _fakeCredentialsAccessor.CallsTo(x => x.CurrentThreadCredentials).Returns(_currentCredentials); }
public void Itinialize() { _fakeBuilder = new FakeClassBuilder<RateLimitCache>(); _credentials = A.Fake<IOAuthCredentials>(); _credentials2 = A.Fake<IOAuthCredentials>(); _tokenRateLimits = A.Fake<ITokenRateLimits>(); _tokenRateLimits2 = A.Fake<ITokenRateLimits>(); }
public void Itinialize() { _fakeBuilder = new FakeClassBuilder <RateLimitCache>(); _credentials = A.Fake <IOAuthCredentials>(); _credentials2 = A.Fake <IOAuthCredentials>(); _tokenRateLimits = A.Fake <ITokenRateLimits>(); _tokenRateLimits2 = A.Fake <ITokenRateLimits>(); }
public ITokenRateLimits GetTokenRateLimits(IOAuthCredentials credentials) { var rateLimits = _rateLimitCache.GetTokenRateLimits(credentials); if (rateLimits == null) { rateLimits = RefreshCredentialsRateLimits(credentials); } return rateLimits; }
public EchoNestMusicService(IWorkContext workContext, mobSocialSettings mobSocialSettings, IOAuthCredentials credentials, IApiUri apiUri) { _mobSocialSettings = mobSocialSettings; _workContext = workContext; _credentials = credentials; _apiUri = apiUri; }
public void Logout() { IOAuthCredentials emptyCred = TwitterCredentials.CreateCredentials("", "", "", ""); TwitterCredentials.Credentials = emptyCred; FOutputStatus[0] = "Logged out!"; FLogger.Log(LogType.Debug, "Logged out!"); ClearOutputPins(); FOutputStatusBool[0] = false; loggedIn = false; }
public ITokenRateLimits GetCredentialsRateLimits(IOAuthCredentials credentials) { var savedCredentials = _credentialsAccessor.CurrentThreadCredentials; _credentialsAccessor.CurrentThreadCredentials = credentials; var rateLimits = GetCurrentCredentialsRateLimits(); _credentialsAccessor.CurrentThreadCredentials = savedCredentials; return(rateLimits); }
/// <summary> /// Generates a Token with a specific OAuthCredentials /// </summary> /// <param name="credentials">Credentials object</param> public OAuthToken(IOAuthCredentials credentials) { if (credentials == null) { throw new ArgumentNullException("credentials"); } Credentials = credentials; _queryGenerator = new OAuthWebRequestGenerator(); }
public void QueryExecuted(string query, IOAuthCredentials credentials, int numberOfRequests = 1) { var rateLimit = _rateLimitCacheManager.GetQueryRateLimit(query, credentials); if (rateLimit != null) { var newRemainingValue = Math.Max(rateLimit.Remaining - numberOfRequests, 0); rateLimit.Remaining = newRemainingValue; } }
public T ExecuteOperationWithCredentials <T>(IOAuthCredentials credentials, Func <T> operation) { var initialCredentials = CurrentThreadCredentials; CurrentThreadCredentials = credentials; var result = operation(); CurrentThreadCredentials = initialCredentials; return(result); }
/// <summary> /// If you need to sign a url and get it as a string, use this method instead of /// using SignUrl() returning a Uri. If you use SignUrl(), as soon as you turn /// the Uri into a string, it unescapes the oauth signature and if it contains '+' characters /// it will fail. /// </summary> public string SignGetUrl(string urlWithParameters, string userToken, string tokenSecret, IOAuthCredentials consumerCredentials) { var oAuthSignatureInfo = new OAuthSignatureInfo { FullUrlToSign = urlWithParameters, ConsumerCredentials = consumerCredentials, HttpMethod = "GET", UserAccessToken = new OAuthAccessToken { Token = userToken, Secret = tokenSecret} }; return _signatureGenerator.Sign(oAuthSignatureInfo); }
public ITokenRateLimits GetTokenRateLimits(IOAuthCredentials credentials) { var rateLimits = _rateLimitCache.GetTokenRateLimits(credentials); if (rateLimits == null) { rateLimits = RefreshCredentialsRateLimits(credentials); } return(rateLimits); }
public static ITokenRateLimits GetCredentialsRateLimits(IOAuthCredentials credentials, bool useRateLimitCache = false) { if (useRateLimitCache) { return(_rateLimitCacheManager.GetTokenRateLimits(credentials)); } else { return(HelpController.GetCredentialsRateLimits(credentials)); } }
public void WaitForCredentialsRateLimit(string query, IOAuthCredentials credentials) { var queryRateLimit = _rateLimitCacheManager.GetQueryRateLimit(query, credentials); var timeToWait = GetTimeToWaitFromQueryRateLimit(queryRateLimit); if (timeToWait > 0) { _queryAwaitingForRateLimitWeakEvent.Raise(this, new QueryAwaitingEventArgs(query, queryRateLimit, credentials)); _threadHelper.Sleep(timeToWait); } }
public void Setup() { _apiUri = A.Fake <IApiUri>(); A.CallTo(() => _apiUri.Uri).Returns("http://example.com"); A.CallTo(() => _apiUri.SecureUri).Returns("https://example.com"); _oAuthCredentials = A.Fake <IOAuthCredentials>(); A.CallTo(() => _oAuthCredentials.ConsumerKey).Returns("testkey"); A.CallTo(() => _oAuthCredentials.ConsumerSecret).Returns("testsecret"); _requestBuilder = new RequestBuilder(_apiUri, _oAuthCredentials); }
public ILoggedUser GetLoggedUser(IOAuthCredentials credentials) { var userDTO = _credentialsAccessor.ExecuteOperationWithCredentials(credentials, () => { return _userFactoryQueryExecutor.GetLoggedUser(); }); var loggedUser = GenerateLoggedUserFromDTO(userDTO); loggedUser.SetCredentials(credentials); return loggedUser; }
public void Setup() { _apiUri = A.Fake<IApiUri>(); A.CallTo(() => _apiUri.Uri).Returns("http://example.com"); A.CallTo(() => _apiUri.SecureUri).Returns("https://example.com"); _oAuthCredentials = A.Fake<IOAuthCredentials>(); A.CallTo(() => _oAuthCredentials.ConsumerKey).Returns("testkey"); A.CallTo(() => _oAuthCredentials.ConsumerSecret).Returns("testsecret"); _requestBuilder = new RequestBuilder(_apiUri, _oAuthCredentials); }
//private IDisposable _oauthCallbackServer; //private string _callbackListenerURI; public WorkerRole() { _applicationCredentials = CredentialsCreator.GenerateApplicationCredentials("UrvdMoVknBFnfO0Y3PsxdAGSn", "sh9YkoVhW4bRyvcKr4Bz4WOIPA05TRwixjMr9hwDz0DTv0v7wX"); _userCredentials = TwitterCredentials.CreateCredentials( "69378065-9cXZ3wy8X1ui35hYcHhsjIR7OdjuaUFo5k92vr3E4", "IOn5rWh8P8IOmEZx1Wd9hacKFchYhblVEAnRyG6dqy8Pz", "UrvdMoVknBFnfO0Y3PsxdAGSn", "sh9YkoVhW4bRyvcKr4Bz4WOIPA05TRwixjMr9hwDz0DTv0v7wX" ); TwitterCredentials.SetCredentials(_userCredentials); }
public ITokenRateLimit GetQueryRateLimit(string query, IOAuthCredentials credentials) { var rateLimits = _rateLimitCache.GetTokenRateLimits(credentials); var queryRateLimit = _rateLimitHelper.GetTokenRateLimitFromQuery(query, rateLimits); if (rateLimits == null || DoesQueryNeedsToRefreshTheCacheInformation(queryRateLimit)) { rateLimits = RefreshCredentialsRateLimits(credentials); queryRateLimit = _rateLimitHelper.GetTokenRateLimitFromQuery(query, rateLimits); } return(queryRateLimit); }
public ITokenRateLimit GetQueryRateLimit(string query, IOAuthCredentials credentials) { var rateLimits = _rateLimitCache.GetTokenRateLimits(credentials); var queryRateLimit = _rateLimitHelper.GetTokenRateLimitFromQuery(query, rateLimits); if (rateLimits == null || DoesQueryNeedsToRefreshTheCacheInformation(queryRateLimit)) { rateLimits = RefreshCredentialsRateLimits(credentials); queryRateLimit = _rateLimitHelper.GetTokenRateLimitFromQuery(query, rateLimits); } return queryRateLimit; }
public void RefreshEntry(IOAuthCredentials credentials, ITokenRateLimits credentialsRateLimits) { lock (_lockTokenRateLimitsDictionary) { if (_tokenRateLimits.ContainsKey(credentials)) { _tokenRateLimits[credentials] = credentialsRateLimits; } else { _tokenRateLimits.Add(credentials, credentialsRateLimits); } } }
public static List <ITweet> SearchTweetsBystream(IOAuthCredentials credentials, string query) { List <ITweet> tweets = new List <ITweet>(); TwitterCredentials.ExecuteOperationWithCredentials(credentials, () => { var searchParam = Search.GenerateSearchTweetParameter(query); searchParam.Lang = Language.English; searchParam.MaximumNumberOfResults = 2000; tweets = Search.SearchTweets(searchParam); }); return(tweets); }
public void TestInitialize() { _fakeBuilder = new FakeClassBuilder<RateLimitAwaiter>(); _fakeRateLimitCacheManager = _fakeBuilder.GetFake<IRateLimitCacheManager>(); _fakeCredentialsAccessor = _fakeBuilder.GetFake<ICredentialsAccessor>(); _fakeThreadHelper = _fakeBuilder.GetFake<IThreadHelper>(); _credentials = A.Fake<IOAuthCredentials>(); _tokenRateLimit = A.Fake<ITokenRateLimit>(); _tokenRateLimit.CallsTo(x => x.Remaining).Returns(0); _tokenRateLimit.CallsTo(x => x.ResetDateTimeInMilliseconds).Returns(TIME_TO_WAIT); _fakeRateLimitCacheManager.CallsTo(x => x.GetQueryRateLimit(TEST_QUERY, _credentials)).Returns(_tokenRateLimit); _fakeCredentialsAccessor.CallsTo(x => x.CurrentThreadCredentials).Returns(_credentials); }
public ITokenRateLimits GetTokenRateLimits(IOAuthCredentials credentials) { lock (_lockTokenRateLimitsDictionary) { ITokenRateLimits credentialsRateLimits; if (_tokenRateLimits.TryGetValue(credentials, out credentialsRateLimits)) { return credentialsRateLimits; } else { return null; } } }
public void TestInitialize() { _fakeBuilder = new FakeClassBuilder <RateLimitAwaiter>(); _fakeRateLimitCacheManager = _fakeBuilder.GetFake <IRateLimitCacheManager>(); _fakeCredentialsAccessor = _fakeBuilder.GetFake <ICredentialsAccessor>(); _fakeThreadHelper = _fakeBuilder.GetFake <IThreadHelper>(); _credentials = A.Fake <IOAuthCredentials>(); _tokenRateLimit = A.Fake <ITokenRateLimit>(); _tokenRateLimit.CallsTo(x => x.Remaining).Returns(0); _tokenRateLimit.CallsTo(x => x.ResetDateTimeInMilliseconds).Returns(TIME_TO_WAIT); _fakeRateLimitCacheManager.CallsTo(x => x.GetQueryRateLimit(TEST_QUERY, _credentials)).Returns(_tokenRateLimit); _fakeCredentialsAccessor.CallsTo(x => x.CurrentThreadCredentials).Returns(_credentials); }
public ITokenRateLimits GetTokenRateLimits(IOAuthCredentials credentials) { lock (_lockTokenRateLimitsDictionary) { ITokenRateLimits credentialsRateLimits; if (_tokenRateLimits.TryGetValue(credentials, out credentialsRateLimits)) { return(credentialsRateLimits); } else { return(null); } } }
public void Clear(IOAuthCredentials credentials) { // We want to lock both the refresh dictionary access so that we ensure the dictionary // is not cleared during a refresh or when it is being accessed lock (_lockRefresh) { lock (_lockTokenRateLimitsDictionary) { if (_tokenRateLimits.ContainsKey(credentials)) { _tokenRateLimits.Remove(credentials); } } } }
public CredentialsViewModel() { if (!Windows.ApplicationModel.DesignMode.DesignModeEnabled) { var test = new OAuthCredentialLoader(); // TODO: File name from configuration. try { _oauthCredentials = test.Load("OAuth.default.secret.json"); // File is marked as "content" - Copy if newer. } catch (Exception ex) { throw ex; } BusyVisibility = ToVisibility(false); ConnectCommand = new RelayCommand(Connect, CanConnect); } else { // Some design-time data. _oauthCredentials = new OAuthCredentials { AccessToken = "asdfghjkl Put your cryptic token here asdfghjkl", AccessTokenSecret = "asdfghjkl Put your cryptic token here asdfghjkl", CallbackUri = "http://www.SpilledMilk.com", ConsumerKey = "asdfghjkl Put your cryptic token here asdfghjkl", ConsumerSecret = "asdfghjkl Put your cryptic token here asdfghjkl" }; BusyVisibility = ToVisibility(true); UserImage = new Uri("http://checkoutmystuff.net/Images/Check Out My Stuff Logo.png"); } CallbackUrl = _oauthCredentials?.CallbackUri; ConsumerKey = _oauthCredentials?.ConsumerKey; ConsumerSecrect = _oauthCredentials?.ConsumerSecret; //if (!IsDesignModeEnabled) //{ // InitializeTwitter(); //} }
private ITokenRateLimits GetTokenRateLimitsFromTwitter(IOAuthCredentials credentials) { if (_isRetrievingData) { return null; } _isRetrievingData = true; var result = _credentialsAccessor.ExecuteOperationWithCredentials(credentials, () => { var twitterQuery = _twitterQueryFactory.Create(_helpQueryGenerator.GetCredentialsLimitsQuery(), HttpMethod.GET, credentials); string jsonResponse = _twitterRequester.ExecuteQuery(twitterQuery); return _jsonObjectConverter.DeserializeObject<ITokenRateLimits>(jsonResponse); }); _isRetrievingData = false; return result; }
public IDictionary<string, string> SignPostRequest(string url, string userToken, string tokenSecret, IOAuthCredentials consumerCredentials, IDictionary<string, string> postParameters) { if (string.IsNullOrEmpty(consumerCredentials.ConsumerKey)) throw new ArgumentException("ConsumerKey can not be null or empty"); if (string.IsNullOrEmpty(consumerCredentials.ConsumerSecret)) throw new ArgumentException("ConsumerSecret can not be null or empty"); var oAuthSignatureInfo = new OAuthSignatureInfo { FullUrlToSign = url, ConsumerCredentials = consumerCredentials, HttpMethod = "POST", UserAccessToken = new OAuthAccessToken { Token = userToken, Secret = tokenSecret }, PostData = postParameters }; return _signatureGenerator.SignWithPostData(oAuthSignatureInfo); }
public static void Initialize() { Credentials = createCredentials(); Authorizer = createAuthorizer(); // while (!Authorizer.IsAuthorized) { Authorizer.Authorize(); // if (Authorizer.IsAuthorized) { SaveToken(); } } // Context = CreateContext(); // Configuration = ( from h in Context.Help where h.Type == HelpType.Configuration select h ).SingleOrDefault().Configuration; // dummyHttpLink = string.Empty.PadRight(Configuration.ShortUrlLength, '.'); dummyHttpsLink = string.Empty.PadRight(Configuration.ShortUrlLengthHttps, '.'); }
public Uri SignUrl(string urlWithParameters, string userToken, string userSecret, IOAuthCredentials consumerCredentials) { var timestamp = _oAuthBase.GenerateTimeStamp(); var nonce = _oAuthBase.GenerateNonce(); string normalizedRequestParameters; string normalizedUrl; var signature = _oAuthBase.GenerateSignature(new Uri(urlWithParameters), consumerCredentials.ConsumerKey, consumerCredentials.ConsumerSecret, userToken, userSecret, "GET", timestamp, nonce, out normalizedUrl, out normalizedRequestParameters, new Dictionary<string, string>()); string escapeDataString = Uri.EscapeDataString(signature); return new Uri(string.Format("{0}?{1}&oauth_signature={2}", normalizedUrl, normalizedRequestParameters, escapeDataString)); }
/// <summary> /// If you need to sign a url and get it as a string, use this method instead of /// using SignUrl() returning a Uri. If you use SignUrl(), as soon as you turn /// the Uri into a string, it unescapes the oauth signature and if it contains '+' characters /// it will fail. /// </summary> public string SignGetUrl(string urlWithParameters, string userToken, string tokenSecret, IOAuthCredentials consumerCredentials) { var timeStamp = _oAuthBase.GenerateTimeStamp(); var nonce = _oAuthBase.GenerateNonce(); string normalizedRequestParameters; string normalizedUrl; var signature = _oAuthBase.GenerateSignature(new Uri(urlWithParameters), consumerCredentials.ConsumerKey, consumerCredentials.ConsumerSecret, userToken, tokenSecret, "GET", timeStamp, nonce, out normalizedUrl, out normalizedRequestParameters, new Dictionary<string, string>()); var encodedSignature = OAuthBase.UrlEncode(signature); return string.Format("{0}?{1}&oauth_signature={2}", normalizedUrl, normalizedRequestParameters, encodedSignature); }
public IDictionary<string, string> SignPostRequest(string url, string userToken, string userSecret, IOAuthCredentials consumerCredentials, Dictionary<string, string> postParameters) { if (string.IsNullOrEmpty(consumerCredentials.ConsumerKey)) throw new ArgumentException("ConsumerKey can not be null or empty"); if (string.IsNullOrEmpty(consumerCredentials.ConsumerSecret)) throw new ArgumentException("ConsumerSecret can not be null or empty"); var timestamp = _oAuthBase.GenerateTimeStamp(); var nonce = _oAuthBase.GenerateNonce(); string normalizedRequestParameters; string normalizedUrl; var signature = _oAuthBase.GenerateSignature(new Uri(url), consumerCredentials.ConsumerKey, consumerCredentials.ConsumerSecret, userToken, userSecret, "POST", timestamp, nonce, out normalizedUrl, out normalizedRequestParameters, postParameters); var parameters = new Dictionary<string, string>(postParameters) { { OAuthBase.OAuthVersionKey, OAuthBase.OAuthVersion }, { OAuthBase.OAuthNonceKey, nonce }, { OAuthBase.OAuthTimestampKey, timestamp }, { OAuthBase.OAuthSignatureMethodKey, OAuthBase.HMACSHA1SignatureType }, { OAuthBase.OAuthConsumerKeyKey, consumerCredentials.ConsumerKey }, { OAuthBase.OAuthSignatureKey, OAuthBase.UrlEncode(signature) } }; if (!string.IsNullOrEmpty(userToken)) { parameters.Add(OAuthBase.OAuthTokenKey, userToken); } return parameters; }
private void InitData() { _loggedUserCredentials = A.Fake<IOAuthCredentials>(); _fakeCredentialsAccessor.CallsTo(x => x.CurrentThreadCredentials).Returns(_loggedUserCredentials); _loggedUser = CreateLoggedUser(); _currentCredentials = A.Fake<IOAuthCredentials>(); _fakeCredentialsAccessor.CallsTo(x => x.CurrentThreadCredentials).Returns(_currentCredentials); }
public static async Task<ITokenRateLimits> GetCredentialsRateLimits(IOAuthCredentials credentials) { return await Sync.ExecuteTaskAsync(() => RateLimit.GetCredentialsRateLimits(credentials)); }
public PostRequestHandler(IApiUri apiUri, IOAuthCredentials oAuthCredentials, IUrlSigner urlSigner) : base(apiUri) { _oAuthCredentials = oAuthCredentials; _urlSigner = urlSigner; }
public Uri SignUrl(string urlWithParameters, string userToken, string userSecret, IOAuthCredentials consumerCredentials) { return new Uri(SignGetUrl(urlWithParameters, userToken, userSecret, consumerCredentials)); }
public ITokenRateLimits GetCredentialsRateLimits(IOAuthCredentials credentials) { return _helpQueryExecutor.GetCredentialsRateLimits(credentials); }