/// <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); }
/// <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); }
/// <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); }
/// <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); }
/// <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; }
/// <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); }
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); }
/// <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); }
/// <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); }
/// <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); }
/// <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); }
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()); }
/// <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); }
/// <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"); } }
/// <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()); }
/// <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()); }