Example #1
0
        public TweetController(TweetsApiService tweetsApiService)
        {
            _credentials = MyCredentials.GenerateCredentials();

            Auth.SetCredentials(_credentials);
            _tweetsApiService = tweetsApiService;
        }
Example #2
0
 private void AssertAreCredentialsEquals(ITwitterCredentials credentials1, ITwitterCredentials 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);
 }
Example #3
0
        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            Console.WriteLine("What topic would you like to get tweets about?");
            string subject = Console.ReadLine();

            while (!stoppingToken.IsCancellationRequested)
            {
                ITwitterCredentials demo = Auth.SetUserCredentials(_options.ConsumerKey, _options.ConsumerSecret, _options.AccessToken, _options.AccessTokenSecret);

                IFilteredStream stream = Stream.CreateFilteredStream();

                stream.AddTrack(subject);

                stream.AddTweetLanguageFilter(LanguageFilter.Portuguese);

                _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
                _logger.LogInformation("I'm listening to twitter");

                stream.MatchingTweetReceived += async(sender, arguments) =>
                {
                    await SendTweetsByKafka(new Tweet()
                    {
                        TweetedBy = arguments.Tweet.CreatedBy.ScreenName, TweetedAt = arguments.Tweet.CreatedAt, Text = arguments.Tweet.Text
                    });
                };

                stream.StartStreamMatchingAllConditions();

                await Task.Delay(5000, stoppingToken);
            }
        }
Example #4
0
        private ICredentialsRateLimits RefreshCredentialsRateLimits(ITwitterCredentials credentials)
        {
            var tokenRateLimits = GetTokenRateLimitsFromTwitter(credentials);

            _rateLimitCache.RefreshEntry(credentials, tokenRateLimits);
            return(_rateLimitCache.GetCredentialsRateLimits(credentials));
        }
 public LinkedIn.Results.IResult<Results.UserIdListResult> GetFollowerIds(ITwitterCredentials credentials, string username)
 {
     return this.executer.Execute(
         credentials, new FollowerIdsCommand {
             ScreenName = username,
         });
 }
Example #6
0
 public LinkedIn.Results.IResult <Results.UserIdListResult> GetFollowerIds(ITwitterCredentials credentials, string username)
 {
     return(this.executer.Execute(
                credentials, new FollowerIdsCommand {
         ScreenName = username,
     }));
 }
Example #7
0
 public IResult <string> UpdateStatus(ITwitterCredentials credentials, string status)
 {
     return(this.executer.Execute(
                credentials, new StatusesUpdateCommand {
         Status = status,
     }));
 }
Example #8
0
        private static T GetConfiguredStream <T>(T stream, ITwitterCredentials credentials, TweetMode?tweetMode) where T : ITwitterStream
        {
            stream.Credentials = credentials ?? ThreadCredentialsAccessor.CurrentThreadCredentials;
            stream.TweetMode   = tweetMode ?? ThreadSettingsAccessor.CurrentThreadSettings.TweetMode;

            return(stream);
        }
Example #9
0
        static void Main(string[] arguments)
        {
            ITwitterCredentials credentials = Login.Instance.getCredentials();

            if (credentials == null)
            {
                credentials = newCredentials();
            }
            ;
            if (credentials == null)
            {
                return;
            }
            Auth.SetCredentials(credentials);

            //AchiveClean.clean();

            while (true)
            {
                Eraser.CreateEraser(15).StartErase();
                Thread.Sleep(1000 * 60 * 10);
            }

            //var application = new Application
            //{
            //    StartupUri = new Uri("MainWindow.xaml", UriKind.RelativeOrAbsolute)
            //};
            //application.Run();
        }
Example #10
0
        // Get User
        public IAuthenticatedUser GetAuthenticatedUser(ITwitterCredentials credentials = null, IGetAuthenticatedUserParameters parameters = null)
        {
            IUserDTO userDTO;

            if (credentials == null)
            {
                credentials = _credentialsAccessor.CurrentThreadCredentials;
                userDTO = _userFactoryQueryExecutor.GetAuthenticatedUser(parameters);
            }
            else
            {
                userDTO = _credentialsAccessor.ExecuteOperationWithCredentials(credentials, () =>
                {
                    return _userFactoryQueryExecutor.GetAuthenticatedUser(parameters);
                });
            }

            var authenticatedUser = GenerateAuthenticatedUserFromDTO(userDTO);

            if (authenticatedUser != null)
            {
                authenticatedUser.SetCredentials(credentials);
            }

            return authenticatedUser;
        }
Example #11
0
 public IResult <Results.Tweet[]> UserTimeline(ITwitterCredentials credentials, string username)
 {
     return(this.executer.Execute(
                credentials, new StatusesUserTimelineCommand {
         Username = username
     }));
 }
Example #12
0
 public TweetProvider(string consumerKey, string consumerSecret, string accessToken,
                      string accessTokenSecret, bool useFakeLocation = false)
 {
     this.credentials = new TwitterCredentials(consumerKey, consumerSecret, accessToken,
                                               accessTokenSecret);
     this.useFakeLocation = useFakeLocation;
 }
 public StreamFactory(ITweetProcessor tweetProcessor, ITwitterCredentials credentials, IFilteredStream stream)
 {
     _tweetProcessor = tweetProcessor;
     _stream         = stream ?? Stream.CreateFilteredStream();
     Auth.SetUserCredentials(credentials.ConsumerKey, credentials.ConsumerSecret,
                             credentials.AccessToken, credentials.AccessTokenSecret);
 }
 public IResult<string> UpdateStatus(ITwitterCredentials credentials, string status)
 {
     return this.executer.Execute(
         credentials, new StatusesUpdateCommand {
             Status = status,
         });
 }
Example #15
0
        // Get User
        public IAuthenticatedUser GetAuthenticatedUser(ITwitterCredentials credentials = null, IGetAuthenticatedUserParameters parameters = null)
        {
            IUserDTO userDTO;

            if (credentials == null)
            {
                credentials = _credentialsAccessor.CurrentThreadCredentials;
                userDTO     = _userFactoryQueryExecutor.GetAuthenticatedUser(parameters);
            }
            else
            {
                userDTO = _credentialsAccessor.ExecuteOperationWithCredentials(credentials, () =>
                {
                    return(_userFactoryQueryExecutor.GetAuthenticatedUser(parameters));
                });
            }

            var authenticatedUser = GenerateAuthenticatedUserFromDTO(userDTO);

            if (authenticatedUser != null)
            {
                authenticatedUser.SetCredentials(credentials);
            }

            return(authenticatedUser);
        }
Example #16
0
        public bool InvalidateCredentials(ITwitterCredentials credentials)
        {
            var url = "https://api.twitter.com/oauth2/invalidate_token";

            var response = _twitterRequestHandler.ExecuteQuery(url, HttpMethod.POST, new InvalidateTokenHttpHandler(), credentials);
            var jobject  = _jObjectStaticWrapper.GetJobjectFromJson(response.Text);

            JToken unused;

            if (jobject.TryGetValue("access_token", out unused))
            {
                return(true);
            }

            try
            {
                var errorsObject = jobject["errors"];
                var errors       = _jObjectStaticWrapper.ToObject <ITwitterExceptionInfo[]>(errorsObject);

                _exceptionHandler.TryLogExceptionInfos(errors, url);
            }
            catch (Exception)
            {
                // Something is definitely wrong!
            }

            return(false);
        }
        public ITwitterQuery Create(string queryURL, HttpMethod httpMethod, ITwitterCredentials twitterCredentials)
        {
            var twitterQuery = Create(queryURL, httpMethod);

            twitterQuery.TwitterCredentials = twitterCredentials;
            return(twitterQuery);
        }
Example #18
0
 public static void GetCredentialsFromConfig()
 {
     _userCredentials = new TwitterCredentials(ConfigurationManager.AppSettings["twitterConsumerKey"],
                                               ConfigurationManager.AppSettings["twitterConsumerSecret"],
                                               ConfigurationManager.AppSettings["twitterAccessToken"],
                                               ConfigurationManager.AppSettings["twitterAccessTokenSecret"]);
 }
Example #19
0
        public bool InitializeApplicationBearer(ITwitterCredentials credentials)
        {
            if (credentials == null)
            {
                throw new TwitterNullCredentialsException();
            }

            if (string.IsNullOrEmpty(credentials.AccessToken) ||
                string.IsNullOrEmpty(credentials.AccessTokenSecret))
            {
                try
                {
                    var response    = _twitterRequestHandler.ExecuteQuery("https://api.twitter.com/oauth2/token", HttpMethod.POST, new BearerHttpHandler(), credentials);
                    var accessToken = Regex.Match(response.Text, "access_token\":\"(?<value>.*)\"").Groups["value"].Value;
                    credentials.ApplicationOnlyBearerToken = accessToken;
                    return(true);
                }
                catch (TwitterException ex)
                {
                    if (_exceptionHandler.LogExceptions)
                    {
                        _exceptionHandler.AddTwitterException(ex);
                    }

                    if (!_exceptionHandler.SwallowWebExceptions)
                    {
                        throw;
                    }
                }
            }

            return(false);
        }
        public static ITwitterCredentials AuthorizeAndGetCredentials(SecureString consumerKey, SecureString consumerSecret)
        {
            string consumerKeyStr    = consumerKey.AsString();
            string consumerSecretStr = consumerSecret.AsString();

            if (consumerKeyStr.Length != 25)
            {
                // Consumer key length check
                Console.WriteLine("Consumer key is not 25 characters long.");

                return(null);
            }

            if (consumerSecretStr.Length != 50)
            {
                // Consumer secret key length check
                Console.WriteLine("Consumer secret is not 50 characters long.");

                return(null);
            }

            Console.WriteLine("Initiating PIN authentiation with given application consumer key/secret...");

            var    auth = AuthFlow.InitAuthentication(new ConsumerCredentials(consumerKeyStr, consumerSecretStr));
            string pinNumber;

            if (OpenUrl(auth.AuthorizationURL))
            {
                Console.WriteLine("Your web browser will be opened and navigate to Twitter app authentication page.");
                Console.WriteLine($"  If not opened, manually open an web browser and navigate to: {auth.AuthorizationURL}\n");
            }
            else
            {
                Console.WriteLine($"Opening URL failed! You can manually open an web browser and navigate to: {auth.AuthorizationURL}\n");
            }

            Console.WriteLine("After logged in, the page will provide 7-character PIN numbers.");
            do
            {
                Console.Write("Please enter the correct PIN numbers here: ");
                pinNumber = Console.ReadLine();
            } while(!(pinNumber.Length == 7 && int.TryParse(pinNumber, out _)));

            Console.WriteLine("\nGetting credential...\n");

            ITwitterCredentials credential = AuthFlow.CreateCredentialsFromVerifierCode(pinNumber, auth);

            if (credential != null && !string.IsNullOrEmpty(credential.AccessToken) && !string.IsNullOrEmpty(credential.AccessTokenSecret))
            {
                Console.WriteLine("Got credential successfully");

                return(credential);
            }
            else
            {
                Console.WriteLine("Null credential. Something's wrong while getting credential.");

                return(null);
            }
        }
 public static async Task SetUserCredentials(long userId, ITwitterCredentials credentials)
 {
     await Task.Run(() =>
     {
         CredentialsByUserId.AddOrUpdate(userId, credentials);
     });
 }
 public IResult<Results.Tweet[]> UserTimeline(ITwitterCredentials credentials, string username)
 {
     return this.executer.Execute(
         credentials, new StatusesUserTimelineCommand {
             Username = username
         });
 }
        public string ExecuteQuery(
            string queryURL, 
            HttpMethod httpMethod, 
            TwitterClientHandler handler = null,
            ITwitterCredentials credentials = null)
        {
            CleanupQueryURL(ref queryURL);
            var rateLimitTrackerOption = _tweetinviSettingsAccessor.RateLimitTrackerOption;
            
            ITwitterQuery twitterQuery;
            if (!TryPrepareRequest(queryURL, httpMethod, rateLimitTrackerOption, credentials, out twitterQuery))
            {
                return null;
            }

            try
            {
                var jsonResult = _twitterRequester.ExecuteQuery(twitterQuery, handler);

                QueryCompleted(twitterQuery, jsonResult, rateLimitTrackerOption);

                return jsonResult;
            }
            catch (TwitterException ex)
            {
                HandleException(queryURL, rateLimitTrackerOption, ex.StatusCode, twitterQuery);
                
                throw;
            }
        }
        public string ExecuteQuery(
            string queryURL,
            HttpMethod httpMethod,
            TwitterClientHandler handler    = null,
            ITwitterCredentials credentials = null)
        {
            CleanupQueryURL(ref queryURL);
            var rateLimitTrackerOption = _tweetinviSettingsAccessor.RateLimitTrackerOption;

            ITwitterQuery twitterQuery;

            if (!TryPrepareRequest(queryURL, httpMethod, rateLimitTrackerOption, credentials, out twitterQuery))
            {
                return(null);
            }

            try
            {
                var jsonResult = _twitterRequester.ExecuteQuery(twitterQuery, handler);

                QueryCompleted(twitterQuery, jsonResult, rateLimitTrackerOption);

                return(jsonResult);
            }
            catch (TwitterException ex)
            {
                HandleException(queryURL, rateLimitTrackerOption, ex.StatusCode, twitterQuery);

                throw;
            }
        }
        private bool TryPrepareRequest(
            string query,
            HttpMethod httpMethod,
            RateLimitTrackerOptions rateLimitTrackerOption,
            ITwitterCredentials credentials,
            out ITwitterQuery twitterQuery)
        {
            twitterQuery = _twitterQueryFactory.Create(query, httpMethod, credentials ?? _credentialsAccessor.CurrentThreadCredentials);

            var beforeQueryExecuteEventArgs = new QueryBeforeExecuteEventArgs(twitterQuery);

            _tweetinviEvents.RaiseBeforeQueryExecute(beforeQueryExecuteEventArgs);

            if (beforeQueryExecuteEventArgs.Cancel)
            {
                twitterQuery = null;
                return(false);
            }

            if (rateLimitTrackerOption == RateLimitTrackerOptions.TrackAndAwait)
            {
                _rateLimitAwaiter.WaitForCurrentCredentialsRateLimit(query);
            }

            return(true);
        }
        private ICredentialsRateLimits GetTokenRateLimitsFromTwitter(ITwitterCredentials credentials)
        {
            if (_isRetrievingData)
            {
                return null;
            }

            var isApplicationOnlyCreds = string.IsNullOrEmpty(credentials.AccessToken) || string.IsNullOrEmpty(credentials.AccessTokenSecret);
            if (isApplicationOnlyCreds && string.IsNullOrEmpty(credentials.ApplicationOnlyBearerToken))
            {
                return null;
            }

            _isRetrievingData = true;
            var result = _credentialsAccessor.ExecuteOperationWithCredentials(credentials, () =>
            {
                var twitterQuery = _twitterQueryFactory.Create(_helpQueryGenerator.GetCredentialsLimitsQuery(), HttpMethod.GET, credentials);

                try
                {
                    string jsonResponse = _twitterRequester.ExecuteQuery(twitterQuery);
                    return _jsonObjectConverter.DeserializeObject<ICredentialsRateLimits>(jsonResponse);
                }
                catch (TwitterException)
                {
                    return null;
                }
            });

            _isRetrievingData = false;
            return result;
        }
Example #27
0
        private ICredentialsRateLimits GetTokenRateLimitsFromTwitter(ITwitterCredentials credentials)
        {
            var isApplicationOnlyCreds = string.IsNullOrEmpty(credentials.AccessToken) || string.IsNullOrEmpty(credentials.AccessTokenSecret);

            if (isApplicationOnlyCreds && string.IsNullOrEmpty(credentials.ApplicationOnlyBearerToken))
            {
                return(null);
            }

            var result = _credentialsAccessor.ExecuteOperationWithCredentials(credentials, () =>
            {
                var twitterQuery = _twitterQueryFactory.Create(_helpQueryGenerator.GetCredentialsLimitsQuery(), HttpMethod.GET, credentials);

                try
                {
                    var webRequestResult = _webRequestExecutor.ExecuteQuery(twitterQuery);
                    var json             = webRequestResult.Text;

                    return(_jsonObjectConverter.DeserializeObject <ICredentialsRateLimits>(json));
                }
                catch (TwitterException)
                {
                    return(null);
                }
            });

            return(result);
        }
Example #28
0
 /// <summary>
 /// Sets user credentials.
 /// </summary>
 private void SetCredentials()
 {
     _credentials = Auth.SetUserCredentials(
         clientConfiguration.ConsumerKey,
         clientConfiguration.ConsumerSecret,
         clientConfiguration.AccessToken,
         clientConfiguration.AccessTokenSecret);
 }
Example #29
0
        public static void GetTwitterAuthorizationUrl()
        {
            _applicationCredentials = new TwitterCredentials(ConfigurationManager.AppSettings["twitterConsumerKey"],
                                                             ConfigurationManager.AppSettings["twitterConsumerSecret"]);
            var url = CredentialsCreator.GetAuthorizationURL(_applicationCredentials);

            System.Diagnostics.Process.Start(url);
        }
Example #30
0
        public TweetinviConnector()
        {
            ExceptionHandler.SwallowWebExceptions = false;
            var conf = ConfigurationManager.AppSettings;

            _twitterCredentials = Auth.SetApplicationOnlyCredentials(conf["Twitter.ConsumerKey"], conf["Twitter.ConsumerSecret"]);
            Auth.InitializeApplicationOnlyCredentials(_twitterCredentials);
        }
Example #31
0
 // Sign
 public static ITwitterRequestParameters GenerateTwitterRequestParameters(
     string query,
     HttpMethod method,
     ITwitterCredentials credentials = null,
     HttpContent content             = null)
 {
     return(Accessor.GenerateTwitterRequestParameters(query, method, credentials, content));
 }
 public ITokenRateLimits GetCredentialsRateLimits(ITwitterCredentials credentials)
 {
     var savedCredentials = _credentialsAccessor.CurrentThreadCredentials;
     _credentialsAccessor.CurrentThreadCredentials = credentials;
     var rateLimits = GetCurrentCredentialsRateLimits();
     _credentialsAccessor.CurrentThreadCredentials = savedCredentials;
     return rateLimits;
 }
Example #33
0
        public async Task <ActionResult> ValidateTwitterAuth(string oauth_verifier, string authorization_id)
        {
            ITwitterCredentials userCredentials = AuthFlow.CreateCredentialsFromVerifierCode(oauth_verifier, authorization_id);

            await SetAuthCookie(userCredentials);

            return(View(_tweetinviService.ValidateTwitterAuth()));
        }
Example #34
0
            public static HetzerCredential fromTwitterCredentials(ITwitterCredentials c)
            {
                var o = new HetzerCredential();

                o.token  = c.AccessToken;
                o.secret = c.AccessTokenSecret;
                return(o);
            }
 public QueryAwaitingEventArgs(
     string query,
     ITokenRateLimit queryRateLimit,
     ITwitterCredentials twitterCredentials)
 {
     _query = query;
     _queryRateLimit = queryRateLimit;
     _twitterCredentials = twitterCredentials;
 }
        public void Itinialize()
        {
            _fakeBuilder = new FakeClassBuilder<RateLimitCache>();

            _credentials = A.Fake<ITwitterCredentials>();
            _credentials2 = A.Fake<ITwitterCredentials>();
            _credentialsRateLimits = A.Fake<ICredentialsRateLimits>();
            _credentialsRateLimits2 = A.Fake<ICredentialsRateLimits>();
        }
Example #37
0
        public static ITwitterCredentials SetApplicationOnlyCredentials(string consumerKey, string consumerSecret, string bearerToken)
        {
            Credentials = new TwitterCredentials(consumerKey, consumerSecret)
            {
                ApplicationOnlyBearerToken = bearerToken
            };

            return(Credentials);
        }
 public QueryAwaitingEventArgs(
     string query,
     IEndpointRateLimit queryRateLimit,
     ITwitterCredentials twitterCredentials)
 {
     _query              = query;
     _queryRateLimit     = queryRateLimit;
     _twitterCredentials = twitterCredentials;
 }
        public void Itinialize()
        {
            _fakeBuilder = new FakeClassBuilder <RateLimitCache>();

            _credentials            = A.Fake <ITwitterCredentials>();
            _credentials2           = A.Fake <ITwitterCredentials>();
            _credentialsRateLimits  = A.Fake <ICredentialsRateLimits>();
            _credentialsRateLimits2 = A.Fake <ICredentialsRateLimits>();
        }
        public ICredentialsRateLimits GetCredentialsRateLimits(ITwitterCredentials credentials)
        {
            var rateLimits = _rateLimitCache.GetCredentialsRateLimits(credentials);
            if (rateLimits == null)
            {
                rateLimits = RefreshCredentialsRateLimits(credentials);
            }

            return rateLimits;
        }
        public ClientProvider(ITwitterCredentials credentials)
        {
            if (credentials == null) throw new ArgumentNullException(nameof(credentials));

            _container = new WindsorContainer();
            _container.AddFacility<TypedFactoryFacility>();

            _container.Register(Component.For<ITwitterCredentials>().Instance(credentials));
            _container.Register(Classes.FromAssemblyInThisApplication().Pick().WithServiceAllInterfaces().LifestyleTransient());
        }
Example #42
0
        public void CheckAuthorization()
        {
            _credentials = _credentialsStore.Load();

            if (string.IsNullOrEmpty(_credentials.ConsumerKey) ||
                string.IsNullOrEmpty(_credentials.ConsumerSecret))
                AuthorizationStatus = AuthorizationStatus.InvalidApplication;
            else
                CheckCredentials();
        }
Example #43
0
        public void QueryExecuted(string query, ITwitterCredentials 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 RequestAuthorizer(ITwitterCredentials credentials, IHttpUtils oAuthUtils)
        {
            if (credentials == null)
                throw new ArgumentNullException("credentials");

            if (oAuthUtils == null)
                throw new ArgumentNullException("oAuthUtils");

            _credentials = credentials;
            _oAuthUtils = oAuthUtils;
        }
Example #45
0
        public void WaitForCredentialsRateLimit(string query, ITwitterCredentials 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 ILoggedUser GetLoggedUser(ITwitterCredentials credentials)
        {
            var userDTO = _credentialsAccessor.ExecuteOperationWithCredentials(credentials, () =>
            {
                return _userFactoryQueryExecutor.GetLoggedUser();
            });

            var loggedUser = GenerateLoggedUserFromDTO(userDTO);
            loggedUser.SetCredentials(credentials);

            return loggedUser;
        }
Example #47
0
        public ICredentialsRateLimits GetCredentialsRateLimits(ITwitterCredentials credentials)
        {
            lock (_lockCredentialsRateLimitsDictionary)
            {
                ICredentialsRateLimits credentialsRateLimits;
                if (credentials != null && _credentialsRateLimits.TryGetValue(credentials, out credentialsRateLimits))
                {
                    return credentialsRateLimits;
                }

                return null;
            }
        }
        public IEndpointRateLimit GetQueryRateLimit(string query, ITwitterCredentials credentials)
        {
            var rateLimits = _rateLimitCache.GetCredentialsRateLimits(credentials);
            var queryRateLimit = _rateLimitHelper.GetEndpointRateLimitFromQuery(query, rateLimits);

            if (rateLimits == null || DoesQueryNeedsToRefreshTheCacheInformation(queryRateLimit))
            {
                rateLimits = RefreshCredentialsRateLimits(credentials);
                queryRateLimit = _rateLimitHelper.GetEndpointRateLimitFromQuery(query, rateLimits);
            }

            return queryRateLimit;
        }
 public void RefreshEntry(ITwitterCredentials credentials, ITokenRateLimits credentialsRateLimits)
 {
     lock (_lockTokenRateLimitsDictionary)
     {
         if (_tokenRateLimits.ContainsKey(credentials))
         {
             _tokenRateLimits[credentials] = credentialsRateLimits;
         }
         else
         {
             _tokenRateLimits.Add(credentials, credentialsRateLimits);
         }
     }
 }
        public void TestInitialize()
        {
            _fakeBuilder = new FakeClassBuilder<RateLimitAwaiter>();
            _fakeRateLimitCacheManager = _fakeBuilder.GetFake<IRateLimitCacheManager>();
            _fakeCredentialsAccessor = _fakeBuilder.GetFake<ICredentialsAccessor>();
            _fakeThreadHelper = _fakeBuilder.GetFake<IThreadHelper>();

            _credentials = A.Fake<ITwitterCredentials>();
            _endpointRateLimit = A.Fake<IEndpointRateLimit>();
            _endpointRateLimit.CallsTo(x => x.Remaining).Returns(0);
            _endpointRateLimit.CallsTo(x => x.ResetDateTimeInMilliseconds).Returns(TIME_TO_WAIT);

            _fakeRateLimitCacheManager.CallsTo(x => x.GetQueryRateLimit(TEST_QUERY, _credentials)).Returns(_endpointRateLimit);
            _fakeCredentialsAccessor.CallsTo(x => x.CurrentThreadCredentials).Returns(_credentials);
        }
 public ITokenRateLimits GetTokenRateLimits(ITwitterCredentials credentials)
 {
     lock (_lockTokenRateLimitsDictionary)
     {
         ITokenRateLimits credentialsRateLimits;
         if (_tokenRateLimits.TryGetValue(credentials, out credentialsRateLimits))
         {
             return credentialsRateLimits;
         }
         else
         {
             return null;
         }
     }
 }
Example #52
0
 public void Clear(ITwitterCredentials 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 (_lockCredentialsRateLimitsDictionary)
         {
             if (_credentialsRateLimits.ContainsKey(credentials))
             {
                 _credentialsRateLimits.Remove(credentials);
             }
         }
     }
 }
Example #53
0
        //Will run in GUI, waits for input.
        public void authenticateUser(string pin)
        {
            // With this pin code it is now possible to get the credentials back from Twitter
            this.userCredentials = AuthFlow.CreateCredentialsFromVerifierCode(pin, authenticationContext);

            // Use the user credentials in your application
            Auth.SetCredentials(this.userCredentials);

            // Get the AuthenticatedUser from the current thread credentials
            this.User = Tweetinvi.User.GetAuthenticatedUser();

            // Stores the usercredentials for later use
            this.storeUserCredentials(this.userCredentials.AccessToken, this.userCredentials.AccessTokenSecret);

            this.twitterUser = new TwitterUser(this.user);
        }
 public IResult<StatusesResult> Tweets(
     ITwitterCredentials credentials, string query, Results.Language? language,
     Results.TweetsResultType? resultType, int? count, DateTime? until, string sinceId, string maxId,
     bool includeEntities)
 {
     return this.executer.Execute(
         credentials, new SearchTweetsCommand {
             Query = query,
             Language = language,
             ResultType = resultType,
             Count = count,
             Until = until,
             SinceId = sinceId,
             MaxId = maxId,
             IncludeEntities = includeEntities,
         });
 }
Example #55
0
        private ITokenRateLimits GetTokenRateLimitsFromTwitter(ITwitterCredentials 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;
        }
Example #56
0
        public void RefreshEntry(ITwitterCredentials credentials, ICredentialsRateLimits newCredentialsRateLimits)
        {
            lock (_lockCredentialsRateLimitsDictionary)
            {
                if (newCredentialsRateLimits == null)
                {
                    return;
                }

                ICredentialsRateLimits currentRateLimits;
                if (_credentialsRateLimits.TryGetValue(credentials, out currentRateLimits))
                {
                    var existingCustomEndpoints = currentRateLimits.OtherEndpointRateLimits;
                    existingCustomEndpoints.ForEach(x => newCredentialsRateLimits.OtherEndpointRateLimits.AddOrUpdate(x));
                }

                _credentialsRateLimits.AddOrUpdate(credentials, newCredentialsRateLimits);
            }
        }
Example #57
0
        public void QueryExecuted(string query, ITwitterCredentials credentials, Dictionary<string, IEnumerable<string>> rateLimitHeaders)
        {
            if (rateLimitHeaders != null && rateLimitHeaders.Count > 0)
            {
                var rateLimit = _rateLimitCacheManager.GetOrCreateQueryRateLimit(query, credentials);

                IEnumerable<string> limitHeaders;
                if (rateLimitHeaders.TryGetValue("x-rate-limit-limit", out limitHeaders))
                {
                    var limit = limitHeaders.FirstOrDefault();
                    if (limit != null)
                    {
                        rateLimit.Limit = int.Parse(limit);
                    }
                }

                IEnumerable<string> remainingHeaders;
                if (rateLimitHeaders.TryGetValue("x-rate-limit-remaining", out remainingHeaders))
                {
                    var remaining = remainingHeaders.FirstOrDefault();
                    if (remaining != null)
                    {
                        rateLimit.Remaining = int.Parse(remaining);
                    }
                }

                IEnumerable<string> resetHeaders;
                if (rateLimitHeaders.TryGetValue("x-rate-limit-reset", out resetHeaders))
                {
                    var reset = resetHeaders.FirstOrDefault();
                    if (reset != null)
                    {
                        rateLimit.Reset = int.Parse(reset);
                    }
                }
            }
            else
            {
                QueryExecuted(query, credentials);
            }
        }
 public static async Task<ITokenRateLimits> GetCredentialsRateLimits(ITwitterCredentials credentials)
 {
     return await Sync.ExecuteTaskAsync(() => RateLimit.GetCredentialsRateLimits(credentials));
 }
 public IResult<Results.Tweet[]> HomeTimeline(ITwitterCredentials credentials)
 {
     return this.executer.Execute(
         credentials, new StatusesHomeTimelineCommand {});
 }
 public IResult<RateLimitStatusResult> Tweets(ITwitterCredentials credentials)
 {
     return this.executer.Execute(credentials, new ApplicationRateLimitStatusCommand());
 }