Пример #1
0
        /// <summary>
        /// Build URL to see if user is subscribed to a list
        /// </summary>
        /// <param name="parameters">Should contain ID and ListID</param>
        /// <returns>URL for IsSubscribed query</returns>
        private string BuildIsSubcribedUrl(Dictionary <string, string> parameters)
        {
            string url = BaseUrl;

            if (parameters.ContainsKey("ListID"))
            {
                ListID = parameters["ListID"];
                url   += parameters["ListID"] + "/subscribers.xml";
            }
            else
            {
                throw new ArgumentException("ListID is required for IsSubscribed query.");
            }

            if (parameters.ContainsKey("ID"))
            {
                ID  = parameters["ID"];
                url = BuildUrlHelper.TransformIDUrl(parameters, url);
            }
            else
            {
                throw new ArgumentException("ID (user ID) is required for IsSubscribed query.");
            }

            return(url);
        }
Пример #2
0
        /// <summary>
        /// appends parameters for Blocking queries
        /// </summary>
        /// <param name="parameters">list of parameters from expression tree</param>
        /// <param name="url">base url</param>
        /// <returns>base url + parameters</returns>
        private string BuildBlockingExistsUrlParameters(Dictionary <string, string> parameters, string url)
        {
            var urlParams = new List <string>();

            if (!parameters.ContainsKey("ID") && !parameters.ContainsKey("UserID") && !parameters.ContainsKey("ScreenName"))
            {
                throw new ArgumentException("You must specify either ID, UserID, or ScreenName.");
            }

            if (parameters.ContainsKey("ID"))
            {
                ID  = parameters["ID"];
                url = BuildUrlHelper.TransformIDUrl(parameters, url);
            }

            if (parameters.ContainsKey("UserID"))
            {
                UserID = ulong.Parse(parameters["UserID"]);
                urlParams.Add("user_id=" + parameters["UserID"]);
            }

            if (parameters.ContainsKey("ScreenName"))
            {
                ScreenName = parameters["ScreenName"];
                urlParams.Add("screen_name=" + parameters["ScreenName"]);
            }

            if (urlParams.Count > 0)
            {
                url += "?" + string.Join("&", urlParams.ToArray());
            }

            return(url);
        }
Пример #3
0
        /// <summary>
        /// builds an url for showing status of user
        /// </summary>
        /// <param name="parameters">parameter list</param>
        /// <returns>base url + show segment</returns>
        private string BuildShowUrl(Dictionary <string, string> parameters)
        {
            var url = BaseUrl + "statuses/show.xml";

            url = BuildUrlHelper.TransformIDUrl(parameters, url);

            return(url);
        }
Пример #4
0
        /// <summary>
        /// construct a base user url
        /// </summary>
        /// <param name="url">base status url</param>
        /// <returns>base url + user timeline segment</returns>
        private string BuildUserUrl(Dictionary <string, string> parameters)
        {
            var url = BaseUrl + "statuses/user_timeline.xml";

            url = BuildUrlHelper.TransformIDUrl(parameters, url);

            url = BuildFriendRepliesAndUrlParameters(parameters, url);

            return(url);
        }
Пример #5
0
        /// <summary>
        /// common code for building parameter list for friends and followers urls
        /// </summary>
        /// <param name="parameters">parameters to add</param>
        /// <param name="url">url to start with</param>
        /// <returns>new url with parameters</returns>
        private string BuildFriendsAndFollowersUrlParameters(Dictionary <string, string> parameters, string url)
        {
            if (parameters == null)
            {
                return(url);
            }

            if (!parameters.ContainsKey("ID") &&
                !parameters.ContainsKey("UserID") &&
                !parameters.ContainsKey("ScreenName"))
            {
                throw new ArgumentException("Parameters must include at least one of ID, UserID, or ScreenName.");
            }

            var urlParams = new List <string>();

            if (parameters.ContainsKey("ID"))
            {
                ID  = parameters["ID"];
                url = BuildUrlHelper.TransformIDUrl(parameters, url);
            }

            if (parameters.ContainsKey("UserID"))
            {
                UserID = parameters["UserID"];
                urlParams.Add("user_id=" + parameters["UserID"]);
            }

            if (parameters.ContainsKey("ScreenName"))
            {
                ScreenName = parameters["ScreenName"];
                urlParams.Add("screen_name=" + parameters["ScreenName"]);
            }

            if (parameters.ContainsKey("Page"))
            {
                Page = int.Parse(parameters["Page"]);
                urlParams.Add("page=" + parameters["Page"]);
            }

            if (parameters.ContainsKey("Cursor"))
            {
                Cursor = parameters["Cursor"];
                urlParams.Add("cursor=" + parameters["Cursor"]);
            }

            if (urlParams.Count > 0)
            {
                url += "?" + string.Join("&", urlParams.ToArray());
            }

            return(url);
        }
        /// <summary>
        /// construct a base show url
        /// </summary>
        /// <param name="url">base show url</param>
        /// <returns>base url + show segment</returns>
        Request BuildShowUrl(Dictionary <string, string> parameters)
        {
            if (!parameters.ContainsKey("ID"))
            {
                throw new ArgumentException("ID is required for a Saved Search Show query.", "ID");
            }

            ID = parameters["ID"];

            var url = BuildUrlHelper.TransformIDUrl(parameters, "saved_searches/show.json");

            return(new Request(BaseUrl + url));
        }
        internal void EncodeCredentials()
        {
            string encodedConsumerKey    = BuildUrlHelper.UrlEncode(Credentials.ConsumerKey);
            string encodedConsumerSecret = BuildUrlHelper.UrlEncode(Credentials.ConsumerSecret);

            string concatenatedCredentials = encodedConsumerKey + ":" + encodedConsumerSecret;

            byte[] credBytes = Encoding.UTF8.GetBytes(concatenatedCredentials);

            string base64Credentials = Convert.ToBase64String(credBytes);

            BasicToken = base64Credentials;
        }
Пример #8
0
        /// <summary>
        /// builds an url for showing status of user
        /// </summary>
        /// <param name="parameters">parameter list</param>
        /// <returns>base url + show segment</returns>
        private string BuildShowUrl(Dictionary <string, string> parameters)
        {
            if (parameters.ContainsKey("ID"))
            {
                ID = parameters["ID"];
            }

            var url = BaseUrl + "statuses/show.xml";

            url = BuildUrlHelper.TransformIDUrl(parameters, url);

            return(url);
        }
        /// <summary>
        /// Builds an URL for finding results related to a specific tweet
        /// </summary>
        /// <param name="parameters">Parameters contain StatusID.</param>
        /// <returns>Url for performing related results show query.</returns>
        private Request BuildShowUrl(Dictionary <string, string> parameters)
        {
            if (parameters == null || !parameters.ContainsKey("StatusID"))
            {
                throw new ArgumentException("StatusID is a required parameter.", "StatusWeoID");
            }

            StatusID = ulong.Parse(parameters["StatusID"]);
            var url = BuildUrlHelper.TransformParameterUrl(parameters, "StatusID", "related_results/show.json");

            var req = new Request(BaseUrl + url);

            return(req);
        }
Пример #10
0
        private string BuildShowUrl(Dictionary <string, string> parameters)
        {
            if (!parameters.ContainsKey("ID"))
            {
                throw new ArgumentNullException("ID", "ID is required.");
            }

            var url = BaseUrl + "direct_messages/show.xml";

            url = BuildUrlHelper.TransformIDUrl(parameters, url);
            ID  = ulong.Parse(parameters["ID"]);

            return(url);
        }
Пример #11
0
        /// <summary>
        /// Builds URL to retrieve info on a specific List
        /// </summary>
        /// <param name="parameters">Contains ID for List</param>
        /// <returns>URL for List query</returns>
        private string BuildListUrl(Dictionary <string, string> parameters)
        {
            string url = BaseUrl + @"lists.xml";

            if (parameters.ContainsKey("ID"))
            {
                ID  = parameters["ID"];
                url = BuildUrlHelper.TransformIDUrl(parameters, url);
            }
            else
            {
                throw new ArgumentException("ID (user ID) is required for List query.");
            }

            return(url);
        }
Пример #12
0
        /// <summary>
        /// Submit a web request using oAuth.
        /// </summary>
        /// <param name="method">GET or POST</param>
        /// <param name="request">Request details</param>
        /// <param name="postData">Data to post (querystring format)</param>
        /// <returns>The web server response.</returns>
        public string OAuthWebRequest(HttpMethod method, Request request, IDictionary <string, string> postData, string callback)
        {
            //Setup postData for signing.
            //Add the postData to the querystring.
            var url = request.FullUrl;

            if (method == HttpMethod.POST)
            {
                if (postData != null && postData.Count > 0)
                {
                    foreach (var postEntry in postData)
                    {
                        if (!string.IsNullOrEmpty(postEntry.Value))
                        {
                            request.RequestParameters.Add(new QueryParameter(postEntry.Key, postEntry.Value));
                        }
                    }
                }
            }

            string nonce     = GenerateNonce();
            string timeStamp = GenerateTimeStamp();
            string outUrl;
            string querystring;

            //Generate Signature
            string sig = GenerateSignature(request,
                                           OAuthConsumerKey,
                                           OAuthConsumerSecret,
                                           OAuthToken,
                                           OAuthTokenSecret,
                                           OAuthVerifier,
                                           callback,
                                           method.ToString(),
                                           timeStamp,
                                           nonce,
                                           OAuthSignatureTypes.Hmacsha1,
                                           out outUrl,
                                           out querystring);

            querystring += "&oauth_signature=" + BuildUrlHelper.UrlEncode(sig);

            var ret = WebRequest(method, url, querystring, postData);

            return(ret);
        }
Пример #13
0
        /// <summary>
        /// construct a url that will request all the retweets of a given tweet
        /// </summary>
        /// <param name="parameters">input parameters</param>
        /// <returns>base url + retweet segment</returns>
        Request BuildRetweetsUrl(Dictionary <string, string> parameters)
        {
            if (parameters.ContainsKey("ID"))
            {
                ID = parameters["ID"];
            }

            var url       = BuildUrlHelper.TransformIDUrl(parameters, "statuses/retweets.json");
            var req       = new Request(BaseUrl + url);
            var urlParams = req.RequestParameters;

            if (parameters.ContainsKey("Count"))
            {
                Count = int.Parse(parameters["Count"]);
                urlParams.Add(new QueryParameter("count", Count.ToString(CultureInfo.InvariantCulture)));
            }

            return(req);
        }
Пример #14
0
        /// <summary>
        /// construct a url that will request all the retweets of a given tweet
        /// </summary>
        /// <param name="parameters">input parameters</param>
        /// <returns>base url + retweet segment</returns>
        private string BuildRetweetsUrl(Dictionary <string, string> parameters)
        {
            var url = BaseUrl + "statuses/retweets.xml";

            if (parameters.ContainsKey("ID"))
            {
                ID = parameters["ID"];
            }

            url = BuildUrlHelper.TransformIDUrl(parameters, url);

            if (parameters.ContainsKey("Count"))
            {
                Count = int.Parse(parameters["Count"]);
                url  += "?count=" + Count;
            }

            return(url);
        }
Пример #15
0
        private string GatherPostData(IDictionary <string, string> postData)
        {
            var queryParams = new StringBuilder();

            if (postData != null && postData.Count > 0)
            {
                foreach (var entry in postData)
                {
                    queryParams
                    .Append(entry.Key)
                    .Append('=')
                    .Append(BuildUrlHelper.UrlEncode(entry.Value))
                    .Append('&');
                }

                queryParams.Length--;   // discard trailing &
            }

            return(queryParams.ToString());
        }
Пример #16
0
        /// <summary>
        /// returns a query string for an OAuth request
        /// </summary>
        /// <param name="url">Twitter query</param>
        /// <returns>Query string with OAuth parameters</returns>
        public void GetOAuthQueryString(HttpMethod method, Request request, string callback, out string outUrl, out string queryString)
        {
            string nonce     = GenerateNonce();
            string timeStamp = GenerateTimeStamp();

            //Generate Signature
            string sig = GenerateSignature(request,
                                           OAuthConsumerKey,
                                           OAuthConsumerSecret,
                                           OAuthToken,
                                           OAuthTokenSecret,
                                           OAuthVerifier,
                                           callback,
                                           method.ToString(),
                                           timeStamp,
                                           nonce,
                                           OAuthSignatureTypes.Hmacsha1,
                                           out outUrl,
                                           out queryString);

            queryString += "&oauth_signature=" + BuildUrlHelper.UrlEncode(sig);
        }
Пример #17
0
        /// <summary>
        /// Generates a signature using the specified signatureType
        /// </summary>
        /// <param name="request">Request details</param>
        /// <param name="consumerKey">The consumer key</param>
        /// <param name="consumerSecret">The consumer seceret</param>
        /// <param name="token">The token, if available. If not available pass null or an empty string</param>
        /// <param name="tokenSecret">The token secret, if available. If not available pass null or an empty string</param>
        /// <param name="callback">Redirect URL for Web apps</param>
        /// <param name="httpMethod">The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)</param>
        /// <param name="nonce">Unique value for this particular request</param>
        /// <param name="signatureType">The type of signature to use</param>
        /// <param name="verifier">Number if using PIN authorization</param>
        /// <param name="timeStamp">Timestamp for this request</param>
        /// <param name="normalizedUrl">Url returned to caller</param>
        /// <param name="normalizedRequestParameters">Parameters returned to caller</param>
        /// <returns>A base64 string of the hash value</returns>
        public string GenerateSignature(Request request, string consumerKey, string consumerSecret, string token, string tokenSecret, string verifier, string callback, string httpMethod, string timeStamp, string nonce, OAuthSignatureTypes signatureType, out string normalizedUrl, out string normalizedRequestParameters)
        {
            normalizedUrl = null;
            normalizedRequestParameters = null;

            switch (signatureType)
            {
            case OAuthSignatureTypes.Plaintext:
                return(BuildUrlHelper.UrlEncode(
                           string.Format(CultureInfo.InvariantCulture, "{0}&{1}", consumerSecret, tokenSecret)));

            case OAuthSignatureTypes.Hmacsha1:
                string signatureBase = GenerateSignatureBase(request, consumerKey, token, tokenSecret, verifier, callback, httpMethod, timeStamp, nonce, Hmacsha1SignatureType, out normalizedUrl, out normalizedRequestParameters);
#if NETFX_CORE
                string hashKey =
                    string.Format(
                        CultureInfo.InvariantCulture, "{0}&{1}",
                        BuildUrlHelper.UrlEncode(consumerSecret),
                        BuildUrlHelper.UrlEncode(tokenSecret));
                return(HashWith(signatureBase, hashKey));
#else
                var hmacsha1 = new HMACSHA1
                {
                    Key =
                        Encoding.UTF8.GetBytes(
                            string.Format(
                                CultureInfo.InvariantCulture, "{0}&{1}",
                                BuildUrlHelper.UrlEncode(consumerSecret),
                                BuildUrlHelper.UrlEncode(tokenSecret)))
                };
                return(ComputeHash(hmacsha1, signatureBase));
#endif
            case OAuthSignatureTypes.Rsasha1:
                throw new NotImplementedException();

            default:
                throw new ArgumentException("Unknown signature type", "signatureType");
            }
        }
Пример #18
0
        /// <summary>
        /// Assembles a series of key=value pairs as a URI-escaped query-string.
        /// </summary>
        /// <param name="parameters">The parameters to include.</param>
        /// <returns>A query-string-like value such as a=b&c=d.  Does not include a leading question mark (?).</returns>
        public static string BuildQueryString(IEnumerable <QueryParameter> parameters)
        {
            if (parameters == null)
            {
                throw new ArgumentNullException("parameters");
            }

            StringBuilder builder = new StringBuilder();

            foreach (var pair in parameters.Where(p => !string.IsNullOrEmpty(p.Value)))
            {
                builder.Append(BuildUrlHelper.UrlEncode(pair.Name));
                builder.Append('=');
                builder.Append(BuildUrlHelper.UrlEncode(pair.Value));
                builder.Append('&');
            }

            if (builder.Length > 1)
            {
                builder.Length--;   // truncate trailing &
            }
            return(builder.ToString());
        }
Пример #19
0
        /// <summary>
        /// Generate the signature base that is used to produce the signature
        /// </summary>
        /// <param name="request">Request details</param>
        /// <param name="consumerKey">The consumer key</param>
        /// <param name="token">The token, if available. If not available pass null or an empty string</param>
        /// <param name="tokenSecret">The token secret, if available. If not available pass null or an empty string</param>
        /// <param name="callback">Redirect URL for Web apps</param>
        /// <param name="httpMethod">The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)</param>
        /// <param name="nonce">Unique value for this particular request</param>
        /// <param name="signatureType">The signature type. To use the default values use <see cref="OAuthBase.SignatureTypes">OAuthBase.SignatureTypes</see>.</param>
        /// <param name="verifier">Number if using PIN authorization</param>
        /// <param name="timeStamp">Timestamp for this request</param>
        /// <param name="normalizedUrl">Url returned to caller</param>
        /// <param name="normalizedRequestParameters">Parameters returned to caller</param>
        /// <returns>The signature base</returns>
        public string GenerateSignatureBase(Request request, string consumerKey, string token, string tokenSecret, string verifier, string callback, string httpMethod, string timeStamp, string nonce, string signatureType, out string normalizedUrl, out string normalizedRequestParameters)
        {
            if (token == null)
            {
                token = string.Empty;
            }

            if (tokenSecret == null)
            {
                tokenSecret = string.Empty;
            }

            if (string.IsNullOrEmpty(consumerKey))
            {
                throw new ArgumentNullException("You must provide a consumerKey.", "consumerKey");
            }

            if (string.IsNullOrEmpty(httpMethod))
            {
                throw new ArgumentNullException("You must provide an httpMethod.", "httpMethod");
            }

            if (string.IsNullOrEmpty(signatureType))
            {
                throw new ArgumentNullException("You must provide a signatureType.", "signatureType");
            }

            var parameters = CloneQueryParameters(request.RequestParameters);

            parameters.Add(new QueryParameter(OAuthVersionKey, OAuthVersion));
            parameters.Add(new QueryParameter(OAuthNonceKey, nonce));
            parameters.Add(new QueryParameter(OAuthTimestampKey, timeStamp));
            parameters.Add(new QueryParameter(OAuthSignatureMethodKey, signatureType));
            parameters.Add(new QueryParameter(OAuthConsumerKeyKey, consumerKey));

            if (!string.IsNullOrEmpty(callback))
            {
                parameters.Add(new QueryParameter(OAuthCallbackKey, callback));
            }

            if (!string.IsNullOrEmpty(token))
            {
                parameters.Add(new QueryParameter(OAuthTokenKey, token));
            }

            if (!string.IsNullOrEmpty(verifier))
            {
                parameters.Add(new QueryParameter(OAuthVerifierKey, verifier));
            }

            // need to UrlEncode (per section 5.1) all the parameter values now, before sorting
            // see: http://hueniverse.com/2008/10/beginners-guide-to-oauth-part-iv-signing-requests/
            foreach (var parm in parameters)
            {
                parm.Value = BuildUrlHelper.UrlEncode(parm.Value);
            }

            parameters.Sort(QueryParameter.defaultComparer);

            var url = new Uri(request.Endpoint);

            normalizedUrl = url.Scheme + "://";
#if !SILVERLIGHT
            normalizedUrl += url.Authority;
#else
            normalizedUrl += url.Host;

            if (!((url.Scheme == "http" && url.Port == 80) ||
                  (url.Scheme == "https" && url.Port == 443)))
            {
                normalizedUrl += ":" + url.Port;
            }
#endif
            normalizedUrl += url.AbsolutePath;
            normalizedRequestParameters = NormalizeRequestParameters(parameters);

            var signatureBase = new StringBuilder();

            signatureBase.AppendFormat(CultureInfo.InvariantCulture, "{0}&", httpMethod.ToUpper());
            signatureBase.AppendFormat(CultureInfo.InvariantCulture, "{0}&", BuildUrlHelper.UrlEncode(normalizedUrl));
            signatureBase.AppendFormat(CultureInfo.InvariantCulture, "{0}", BuildUrlHelper.UrlEncode(normalizedRequestParameters));

            return(signatureBase.ToString());
        }