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