Exemple #1
0
        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;
		}
Exemple #3
0
        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);
        }
Exemple #4
0
        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);
 }
Exemple #8
0
 public RequestCoordinator(IHttpClient httpClient, IUrlSigner urlSigner, IOAuthCredentials oAuthCredentials, IApiUri apiUri)
 {
     HttpClient        = httpClient;
     _urlSigner        = urlSigner;
     _oAuthCredentials = oAuthCredentials;
     _apiUri           = apiUri;
 }
Exemple #9
0
 public OAuthService(IApiUri apiUri, IOAuthCredentials credentials)
 {
     Uri            = apiUri.Uri;
     SecureUri      = apiUri.SecureUri;
     ConsumerKey    = credentials.ConsumerKey;
     ConsumerSecret = credentials.ConsumerSecret;
 }
Exemple #10
0
 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);
        }
Exemple #12
0
 public ITwitterAuthentificationResponse Authentificate(IOAuthCredentials oAuthCredentials)
 {
     if (oAuthCredentials == null)
     {
         throw new ApplicationException("OAuth credentials are null");
     }
     return(Authentificate(oAuthCredentials.ApiKey, oAuthCredentials.ApiSecret));
 }
Exemple #13
0
        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;
 }
Exemple #16
0
        public ILoggedUser GetLoggedUser(IOAuthCredentials credentials)
        {
            var userDTO = _credentialsAccessor.ExecuteOperationWithCredentials(credentials, () =>
            {
                return(_userFactoryQueryExecutor.GetLoggedUser());
            });

            return(GenerateLoggedUserFromDTO(userDTO));
        }
 public QueryAwaitingEventArgs(
     string query,
     ITokenRateLimit queryRateLimit,
     IOAuthCredentials oAuthCredentials)
 {
     _query = query;
     _queryRateLimit = queryRateLimit;
     _oAuthCredentials = oAuthCredentials;
 }
        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;
        }
Exemple #22
0
 public EchoNestMusicService(IWorkContext workContext,
                             mobSocialSettings mobSocialSettings,
                             IOAuthCredentials credentials,
                             IApiUri apiUri)
 {
     _mobSocialSettings = mobSocialSettings;
     _workContext       = workContext;
     _credentials       = credentials;
     _apiUri            = apiUri;
 }
Exemple #23
0
        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);
        }
Exemple #25
0
        /// <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;
            }
        }
Exemple #27
0
        public T ExecuteOperationWithCredentials <T>(IOAuthCredentials credentials, Func <T> operation)
        {
            var initialCredentials = CurrentThreadCredentials;

            CurrentThreadCredentials = credentials;
            var result = operation();

            CurrentThreadCredentials = initialCredentials;
            return(result);
        }
        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;
            }
        }
		/// <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);
		}
Exemple #30
0
        public ITokenRateLimits GetTokenRateLimits(IOAuthCredentials credentials)
        {
            var rateLimits = _rateLimitCache.GetTokenRateLimits(credentials);

            if (rateLimits == null)
            {
                rateLimits = RefreshCredentialsRateLimits(credentials);
            }

            return(rateLimits);
        }
Exemple #31
0
 public static ITokenRateLimits GetCredentialsRateLimits(IOAuthCredentials credentials, bool useRateLimitCache = false)
 {
     if (useRateLimitCache)
     {
         return(_rateLimitCacheManager.GetTokenRateLimits(credentials));
     }
     else
     {
         return(HelpController.GetCredentialsRateLimits(credentials));
     }
 }
Exemple #32
0
        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 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);
        }
Exemple #35
0
        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);
        }
Exemple #38
0
        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);
         }
     }
 }
Exemple #41
0
        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 RefreshEntry(IOAuthCredentials 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<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 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);
             }
         }
     }
 }
Exemple #49
0
        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);
		}
Exemple #52
0
 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);
 }