public string authorizationHeader(Dictionary <string, string> oauth)
{
// Convert to UTF-8 & RFC3986 (urlencode) & Sort all parameters
SortedDictionary <string, string> encodedParameters = new SortedDictionary <string, string>();
foreach (KeyValuePair <string, string> entry in oauth)
{
encodedParameters.Add(AdskRESTful.UrlEncode(entry.Key), AdskRESTful.UrlEncode(entry.Value));
}
string[] oauthArray = new string[encodedParameters.Count];
int n = 0;
foreach (KeyValuePair <string, string> entry in encodedParameters)
{
if (entry.Key != "oauth_signature")
{
oauthArray[n++] = string.Format("{0}=\"{1}\"", entry.Key, entry.Value);
}
}
oauthArray[n++] = string.Format("{0}=\"{1}\"", AdskRESTful.UrlEncode("oauth_signature"), encodedParameters[AdskRESTful.UrlEncode("oauth_signature")]);
string oauthHeader = string.Join(", ", oauthArray);
oauthHeader = string.Format("OAuth {0}", oauthHeader);
return(oauthHeader);
}
/////////////////////////////////////////////////////////////////////////////////
// ReCap Client Constructor
//
/////////////////////////////////////////////////////////////////////////////////
public AdnReCapClient(
string serviceUrl,
string clientID,
string consumerKey,
string consumerSecret,
string accessToken,
string accessTokenSecret)
{
_clientId = clientID;
_restClient = new RestClient(serviceUrl);
_restClient.Authenticator =
OAuth1Authenticator.ForProtectedResource(
consumerKey,
consumerSecret,
accessToken,
accessTokenSecret);
_Client2 = new AdskRESTful(serviceUrl);
_Client2.addSubscriber(
new AdskOauthPlugin(
new Dictionary <string, string> ()
{
{ "oauth_consumer_key", consumerKey },
{ "oauth_consumer_secret", consumerSecret },
{ "oauth_token", accessToken },
{ "oauth_token_secret", accessTokenSecret }
}));
}
// https://dev.twitter.com/docs/auth/creating-signature
//
// These values need to be encoded into a single string which will be used later on. The process to build the string is very specific:
//
// Percent encode every key and value to be signed.
// Sort the list of parameters alphabetically[1] by encoded key[2].
// For each key/value pair:
// Append the encoded key to the output string
// Append the '=' character to the output string
// Append the encoded value to the output string
// If there are more key/value pairs remaining, append a '&' character to the output string.
// [1] Note: The Oauth spec says to sort lexigraphically, which is the default alphabetical sort for many libraries
// [2] Note: In case of two parameters with the same encoded key, the Oauth spec says to continue sorting based on value
//
// To encode the HTTP method, base URL, and parameter string into a single string:
//
// Convert the HTTP method to uppercase
// Append the '&' character
// Append Percent encode the URL
// Append the '&' character
// Append Percent encode the parameter string
public string sign(string method, Uri url, Dictionary <string, string> parameters)
{
// @"oauth_consumer_secret" @"oauth_token_secret"
string signatureSecret = string.Format("{0}&{1}",
AdskRESTful.UrlEncode(_tokens["oauth_consumer_secret"]),
(_tokens.ContainsKey("oauth_token_secret") ? AdskRESTful.UrlEncode(_tokens["oauth_token_secret"]) : "")
);
// Convert to UTF-8 & RFC3986 (urlencode) & Sort all parameters
SortedDictionary <string, string> encodedParameters = new SortedDictionary <string, string>();
foreach (KeyValuePair <string, string> entry in parameters)
{
encodedParameters.Add(AdskRESTful.UrlEncode(entry.Key), AdskRESTful.UrlEncode(entry.Value));
}
// Build string to be signed
//Queue<string> orderedParameters =new Queue<string> () ;
//foreach ( KeyValuePair<string, string> entry in encodedParameters )
// orderedParameters.Enqueue (string.Format ("{0}={1}", entry.Key, entry.Value)) ;
string[] parametersArray = new string[encodedParameters.Count];
int n = 0;
foreach (KeyValuePair <string, string> entry in encodedParameters)
{
parametersArray[n++] = string.Format("{0}={1}", entry.Key, entry.Value);
}
string parametersString = string.Join("&", parametersArray);
string urlString = url.AbsoluteUri; // =string.Format ("{0}://{1}{2}", [url scheme], [url host], [url path]) ;
string stringToSign = string.Format("{0}&{1}&{2}",
AdskRESTful.UrlEncode(method.ToUpperInvariant()),
AdskRESTful.UrlEncode(urlString),
AdskRESTful.UrlEncode(parametersString)
);
// Sign it
using (HMACSHA1 hashAlgorithm = new HMACSHA1(Encoding.UTF8.GetBytes(signatureSecret)))
{
return(Convert.ToBase64String(hashAlgorithm.ComputeHash(Encoding.UTF8.GetBytes(stringToSign))));
}
}
protected HttpWebRequest buildRequest(string method, string url, Dictionary <string, string> headers)
{
Uri rUrl;
if (url.ToLower().Contains("http"))
{
rUrl = new Uri(url);
}
else
{
rUrl = new Uri(_url, url);
}
// If default headers are provided, then merge them under any explicitly provided headers for the request
Dictionary <string, string> reqHeaders = new Dictionary <string, string>();
if (headers != null)
{
reqHeaders.Concat(headers);
}
// Get credential (Oauth) parameters
// Get query (GET) and/or body (POST) + Credential (Oauth) parameters
Dictionary <string, string> oauth = _credential.parameters;
// Combine oAuth & parameters
Dictionary <string, string> dict = oauth;
// http://tools.ietf.org/html/rfc5849#section-3.4.1.3 << Oauth 1.0a
// Include all GET and POST parameters before generating the signature
// according to the RFC 5849 - The OAuth 1.0 Protocol http://tools.ietf.org/html/rfc5849#section-3.4.1
// if this change causes trouble we need to introduce a flag indicating the specific OAuth implementation level,
// or implement a seperate class for each OAuth version
if (AlwaysSignParameters || ((_files == null || _files.Count == 0) && !AlwaysMultipart))
{
dict = dict.Concat(_parameters)
.GroupBy(kvp => kvp.Key, kvp => kvp.Value)
.ToDictionary(g => g.Key, g => g.Last());
}
if (dict.ContainsKey("realm") == true)
{
dict.Remove("realm");
}
oauth["oauth_signature"] = _credential.sign(method, rUrl, dict);
reqHeaders["Authorization"] = _credential.authorizationHeader(oauth);
System.Diagnostics.Debug.WriteLine("Authorization: " + reqHeaders["Authorization"]);
//reqHeaders ["User-Agent"] ="AdskRESTful/1.0" ;
//reqHeaders ["Accept-Encoding"] =null/*@"gzip, deflate"*/ ;
//reqHeaders ["Accept-Language"] =null ;
//reqHeaders ["Accept"] =null ;
//reqHeaders ["Pragma"] =null ;
if (method.ToLower() == "get")
{
// Convert to UTF-8 & RFC3986 (urlencode)
string[] encodedParameters = new string[_parameters.Count];
int n = 0;
foreach (KeyValuePair <string, string> entry in _parameters)
{
encodedParameters[n++] = string.Format("{0}={1}", AdskRESTful.UrlEncode(entry.Key), AdskRESTful.UrlEncode(entry.Value));
}
string queryString = string.Join("&", encodedParameters);
string st = string.Format("{0}{1}{2}",
rUrl.AbsoluteUri,
rUrl.AbsoluteUri.Contains("?") ? "&" : "?",
queryString
);
rUrl = new Uri(st);
}
HttpWebRequest req = (HttpWebRequest)WebRequest.Create(rUrl);
req.KeepAlive = false;
req.Method = method.ToUpperInvariant();
HttpRequestCachePolicy policy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
req.CachePolicy = policy;
//req.Timeout =100 ;
req.UserAgent = "AdskRESTful/1.0";
foreach (KeyValuePair <string, string> entry in reqHeaders)
{
req.Headers.Add(entry.Key, entry.Value);
}
if (method.ToLower() == "post" ||
method.ToLower() == "put" ||
method.ToLower() == "delete"
)
{
string bodyString = "";
if (!AlwaysMultipart && (_files == null || _files.Count == 0) && _parameters.Count != 0)
{
// Convert to UTF-8 & RFC3986 (urlencode)
if (_parameters != null)
{
string[] encodedParameters = new string[_parameters.Count];
int n = 0;
foreach (KeyValuePair <string, string> entry in _parameters)
{
encodedParameters[n++] = string.Format("{0}={1}", AdskRESTful.UrlEncode(entry.Key), AdskRESTful.UrlEncode(entry.Value));
}
bodyString = string.Join("&", encodedParameters);
}
req.ContentType = "application/x-www-form-urlencoded; charset=utf-8";
}
else
{
string boundaryCode = AdskRESTful.nonce().Substring(0, 12).ToLower();
string boundary = "----------------------------" + boundaryCode;
req.ContentType = "multipart/form-data; boundary=" + boundary;
if (_parameters != null)
{
foreach (KeyValuePair <string, string> entry in _parameters)
{
bodyString += "--" + boundary + "\r\n";
bodyString += "Content-Disposition: form-data; name=\"" + entry.Key + "\"\r\n\r\n";
bodyString += entry.Value + "\r\n";
}
}
if (_files != null)
{
int i = 0;
foreach (KeyValuePair <string, string> entry in _files)
{
string keyName = string.Format("file[{0}]", i);
//string contentType =[AdskRESTful fileMIMEType:key] ;
string contentType = "image/jpeg";
bodyString += "--" + boundary + "\r\n";
bodyString += "Content-Disposition: form-data; name=\"" + keyName + "\"; filename=\"" + AdskRESTful.UrlEncode(entry.Key) + "\"\r\n\r\n";
bodyString += "Content-Type: " + contentType + "\r\n\r\n";
bodyString += entry.Value;
bodyString += "\r\n";
i++;
}
}
bodyString += "--" + boundary + "--\r\n";
}
byte[] byte1 = Encoding.UTF8.GetBytes(bodyString);
//req.ContentLength =byte1.Length ;
try
{
System.IO.Stream body = req.GetRequestStream();
body.Write(byte1, 0, byte1.Length);
body.Close();
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
}
return(req);
}
