/// <summary>
/// Get the actual RateLimit for the UserTimeline
/// </summary>
/// <returns></returns>
public RateLimit GetRateLimitForUserTimeline()
{
var tokens = new OAuthTokens
{
AccessToken = _accessToken,
AccessTokenSecret = _accessTokenSecret,
ConsumerKey = _consumerKey,
ConsumerSecret = _consumerSecret
};
string responseString = null;
var proxy = new WebRequestBuilder(new Uri(RateLimitStatusesUrl), HTTPVerb.GET, tokens);
using (var response = proxy.ExecuteRequest())
{
using (var responseStream = response.GetResponseStream())
{
if (responseStream != null)
{
using (var reader = new StreamReader(responseStream))
{
responseString = reader.ReadToEnd();
reader.Close();
}
}
}
}
var index = responseString.IndexOf("/statuses/user_timeline", System.StringComparison.Ordinal);
if (index < 0)
{
return(null);
}
var result = new RateLimit();
var value = GetValue(responseString, index, "limit");
if (string.IsNullOrEmpty(value))
{
return(null);
}
result.Limit = int.Parse(value);
value = GetValue(responseString, index, "remaining");
if (string.IsNullOrEmpty(value))
{
return(null);
}
result.LimitRemaining = int.Parse(value);
value = GetValue(responseString, index, "reset");
if (string.IsNullOrEmpty(value))
{
return(null);
}
result.UtcLimitReset = ConvertFromUnixTimestamp(double.Parse(value));
return(result);
}
/// <summary>
/// See https://dev.twitter.com/docs/api/1.1/get/statuses/user_timeline
/// </summary>
/// <param name="screenName">screen name</param>
/// <param name="count">number of tweets to be retrieved</param>
public List <UserTimelineResponse> GetUserTimeLine(string screenName, int count, out RateLimit rateLimit)
{
// Return results in a List of UserTimelineResponse
List <UserTimelineResponse> result = null;
// Define new OAuthTokens
OAuthTokens tokens = new OAuthTokens
{
AccessToken = _accessToken,
AccessTokenSecret = _accessTokenSecret,
ConsumerKey = _consumerKey,
ConsumerSecret = _consumerSecret
};
// Concat a request string
string url = UserTimelineUrl + "count=" + count + "&screen_name=" + screenName;
// Use the WebRequest and WebResponse to execute request and retrieve the response
WebRequestBuilder proxy = new WebRequestBuilder(new Uri(url), HTTPVerb.GET, tokens);
// Execute the request
using (HttpWebResponse response = proxy.ExecuteRequest())
{
string responseString = null;
// Define our RateLimit (
rateLimit = new RateLimit();
rateLimit.Limit = int.Parse(response.Headers["X-Rate-Limit-Limit"]);
rateLimit.LimitRemaining = int.Parse(response.Headers["X-Rate-Limit-Remaining"]);
rateLimit.UtcLimitReset = ConvertFromUnixTimestamp(double.Parse(response.Headers["X-Rate-Limit-Reset"]));
using (var responseStream = response.GetResponseStream())
{
if (responseStream != null)
{
using (var reader = new StreamReader(responseStream))
{
responseString = reader.ReadToEnd();
reader.Close();
}
}
}
// JsonSerializer to get back a strongly typed object (UserTimelineResponse)
JsonSerializer serializer = new JsonSerializer();
result = (List <UserTimelineResponse>)serializer.Deserialize(new JsonTextReader(new StringReader(responseString)), typeof(List <UserTimelineResponse>));
}
return(result);
}
internal static string ExecuteAuthenticatedWebRequest(string twitterQuery, OAuthTokens tokens, bool retry = true)
{
//get mentions
string responseText = string.Empty;
WebResponse response;
try
{
WebRequestBuilder requestBuilder = new WebRequestBuilder(new Uri(twitterQuery), HTTPVerb.GET, tokens);
response = requestBuilder.ExecuteRequest();
if (!Object.Equals(response, null))
{
responseText = BuildTextFromResponse(response);
if (string.IsNullOrEmpty(responseText))
{
ExceptionExtensions.LogWarning(new ArgumentNullException("Twitter responseText from the httpwebresponse was empty"), "Twitter ExecuteAuthenticatedWebRequest", "Query: " + twitterQuery);
}
}
else
{
ExceptionExtensions.LogWarning(new ArgumentNullException("Twitter httwebresponse object was null"), "Twitter ExecuteAuthenticatedWebRequest", "Query: " + twitterQuery);
}
}
catch (Exception e)
{
if (retry)
{
if (e.Message.Contains("429") || e.Message.Contains("420"))
{
ExceptionExtensions.LogWarning(e, "Twitter.Request.ExecuteAuthenticatedWebRequest");
Thread.Sleep(300000); //wait 5 min because of rate limiting
}
else
{
Thread.Sleep(60000);
}
ExecuteAuthenticatedWebRequest(twitterQuery, tokens, false);
}
else
{
ExceptionExtensions.LogError(e, "Drone.API.Twitter.Request.ExecuteAuthenticatedWebRequest", twitterQuery);
}
}
return(responseText);
}
/// <summary>
/// Executes the command.
/// </summary>
/// <returns>The results of the command.</returns>
public TwitterResponse <T> ExecuteCommand()
{
TwitterResponse <T> twitterResponse = new TwitterResponse <T>();
if (this.OptionalProperties.UseSSL)
{
this.Uri = new Uri(this.Uri.AbsoluteUri.Replace("http://", "https://"));
}
// Loop through all of the custom attributes assigned to the command class
foreach (Attribute attribute in this.GetType().GetCustomAttributes(false))
{
if (attribute is AuthorizedCommandAttribute)
{
if (this.Tokens == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "Tokens are required for the \"{0}\" command.", this.GetType()));
}
if (string.IsNullOrEmpty(this.Tokens.ConsumerKey) ||
string.IsNullOrEmpty(this.Tokens.ConsumerSecret) ||
string.IsNullOrEmpty(this.Tokens.AccessToken) ||
string.IsNullOrEmpty(this.Tokens.AccessTokenSecret))
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "Token values cannot be null when executing the \"{0}\" command.", this.GetType()));
}
}
else if (attribute is RateLimitedAttribute)
{
// Get the rate limiting status
if (TwitterRateLimitStatus.GetStatus(this.Tokens).ResponseObject.RemainingHits == 0)
{
throw new TwitterizerException("You are being rate limited.");
}
}
}
// Prepare the query parameters
Dictionary <string, object> queryParameters = new Dictionary <string, object>();
foreach (KeyValuePair <string, object> item in this.RequestParameters)
{
queryParameters.Add(item.Key, item.Value);
}
// Declare the variable to be returned
twitterResponse.ResponseObject = default(T);
twitterResponse.RequestUrl = this.Uri.AbsoluteUri;
RateLimiting rateLimiting;
AccessLevel accessLevel;
byte[] responseData;
try
{
WebRequestBuilder requestBuilder = new WebRequestBuilder(this.Uri, this.Verb, this.Tokens)
{
Multipart = this.Multipart
};
#if !SILVERLIGHT
if (this.OptionalProperties != null)
{
requestBuilder.Proxy = this.OptionalProperties.Proxy;
}
#endif
foreach (var item in queryParameters)
{
requestBuilder.Parameters.Add(item.Key, item.Value);
}
HttpWebResponse response = requestBuilder.ExecuteRequest();
if (response == null)
{
twitterResponse.Result = RequestResult.Unknown;
return(twitterResponse);
}
responseData = ConversionUtility.ReadStream(response.GetResponseStream());
twitterResponse.Content = Encoding.UTF8.GetString(responseData, 0, responseData.Length);
twitterResponse.RequestUrl = requestBuilder.RequestUri.AbsoluteUri;
#if !SILVERLIGHT
// Parse the rate limiting HTTP Headers
rateLimiting = ParseRateLimitHeaders(response.Headers);
// Parse Access Level
accessLevel = ParseAccessLevel(response.Headers);
#else
rateLimiting = null;
accessLevel = AccessLevel.Unknown;
#endif
// Lookup the status code and set the status accordingly
SetStatusCode(twitterResponse, response.StatusCode, rateLimiting);
twitterResponse.RateLimiting = rateLimiting;
twitterResponse.AccessLevel = accessLevel;
}
catch (WebException wex)
{
if (new[]
{
#if !SILVERLIGHT
WebExceptionStatus.Timeout,
WebExceptionStatus.ConnectionClosed,
#endif
WebExceptionStatus.ConnectFailure
}.Contains(wex.Status))
{
twitterResponse.Result = RequestResult.ConnectionFailure;
twitterResponse.ErrorMessage = wex.Message;
return(twitterResponse);
}
// The exception response should always be an HttpWebResponse, but we check for good measure.
HttpWebResponse exceptionResponse = wex.Response as HttpWebResponse;
if (exceptionResponse == null)
{
throw;
}
responseData = ConversionUtility.ReadStream(exceptionResponse.GetResponseStream());
twitterResponse.Content = Encoding.UTF8.GetString(responseData, 0, responseData.Length);
#if !SILVERLIGHT
rateLimiting = ParseRateLimitHeaders(exceptionResponse.Headers);
// Parse Access Level
accessLevel = ParseAccessLevel(exceptionResponse.Headers);
#else
rateLimiting = null;
accessLevel = AccessLevel.Unknown;
#endif
// Try to read the error message, if there is one.
try
{
TwitterErrorDetails errorDetails = SerializationHelper <TwitterErrorDetails> .Deserialize(responseData);
twitterResponse.ErrorMessage = errorDetails.ErrorMessage;
}
catch (Exception)
{
// Occasionally, Twitter responds with XML error data even though we asked for json.
// This is that scenario. We will deal with it by doing nothing. It's up to the developer to deal with it.
}
// Lookup the status code and set the status accordingly
SetStatusCode(twitterResponse, exceptionResponse.StatusCode, rateLimiting);
twitterResponse.RateLimiting = rateLimiting;
twitterResponse.AccessLevel = accessLevel;
if (wex.Status == WebExceptionStatus.UnknownError)
{
throw;
}
return(twitterResponse);
}
try
{
twitterResponse.ResponseObject = SerializationHelper <T> .Deserialize(responseData, this.DeserializationHandler);
}
catch (Newtonsoft.Json.JsonReaderException)
{
twitterResponse.ErrorMessage = "Unable to parse JSON";
twitterResponse.Result = RequestResult.Unknown;
return(twitterResponse);
}
catch (Newtonsoft.Json.JsonSerializationException)
{
twitterResponse.ErrorMessage = "Unable to parse JSON";
twitterResponse.Result = RequestResult.Unknown;
return(twitterResponse);
}
// Pass the current oauth tokens into the new object, so method calls from there will keep the authentication.
twitterResponse.Tokens = this.Tokens;
return(twitterResponse);
}
private List <TwitterEntity> GetLatestTweets(string handle)
{
List <TwitterEntity> tweets = new List <TwitterEntity>();
#region Twitter Library Setup
OAuthTokens oaccesstkn = new OAuthTokens();
string consumerKey = ConfigurationManager.AppSettings["TwitterConsumerKey"];
string consumerSecret = ConfigurationManager.AppSettings["TwitterConsumerSecret"];
oaccesstkn.AccessToken = ConfigurationManager.AppSettings["TwitterAccessToken"];
oaccesstkn.AccessTokenSecret = ConfigurationManager.AppSettings["TwitterAccessSecret"];;
oaccesstkn.ConsumerKey = consumerKey;
oaccesstkn.ConsumerSecret = consumerSecret;
#endregion
try
{
#region Get Tweets From Twitter
WebRequestBuilder webRequest = new WebRequestBuilder(new Uri(string.Format(ConfigurationManager.AppSettings["TwitterUrl"], handle, 500)), HTTPVerb.GET, oaccesstkn);
string responseText;
using (var response = webRequest.ExecuteRequest())
{
using (var reader = new StreamReader(response.GetResponseStream()))
{
responseText = reader.ReadToEnd();
}
}
var brr = Encoding.UTF8.GetBytes(responseText);
var streamReader = new StreamReader(new MemoryStream(brr));
var serializer = new DataContractJsonSerializer(typeof(SearchResults));
var tweetsResponse = (SearchResults)serializer.ReadObject(streamReader.BaseStream);
streamReader.Close();
#endregion
foreach (var mmTweetData in tweetsResponse.Results)
{
var tweetId = mmTweetData.Id.ToString();
try
{
var myTweet = new TwitterEntity
{
RowKey = Guid.NewGuid().ToString(),
TwitterId = tweetId,
TwitterIdString = mmTweetData.Id_Str,
TextMessage = mmTweetData.Text,
Source = mmTweetData.Source,
FromUser = mmTweetData.Source,
FromUserId = mmTweetData.ToUserName,
ProfileImageUrl = mmTweetData.User.ProfileImageUrl,
ProfileSecureImageUrl = mmTweetData.User.ProfileImageUrlHttps,
ReplyUserId = mmTweetData.User.FromUserId.ToString(),
ReplyScreenName = mmTweetData.User.FromUser,
ResultType = mmTweetData.SearchMetaData.ResultType,
LanguageCode = mmTweetData.SearchMetaData.IsoLanguageCode,
Created_At = ParseTwitterDateTime(mmTweetData.CreatedAt),
Status = "-1"
};
tweets.Add(myTweet);
}
catch (Exception)
{
}
}
}
catch (Exception)
{
}
return(tweets);
}
/// <summary>
///
/// </summary>
/// <param name="overrideVerb"></param>
/// <returns></returns>
protected virtual TwitterResponse<string> ExecuteRequest(HTTPVerb overrideVerb)
{
this.Verb = overrideVerb;
if (String.IsNullOrEmpty(this.Method))
throw new ArgumentNullException("Method");
WebRequestBuilder builder = new WebRequestBuilder(
new Uri(this.BaseUri + this.Method),
this.Verb,
this.Tokens);
string responseBody = String.Empty;
try
{
if (this.AdditionalParameters.Count > 0)
{
foreach (var item in this.AdditionalParameters)
builder.Parameters.Add(item.Key, item.Value);
if(this.Verb==HTTPVerb.POST)
builder.Multipart = true;
}
HttpWebResponse webResponse = builder.ExecuteRequest();
Stream responseStream = webResponse.GetResponseStream();
if (responseStream != null) responseBody = new StreamReader(responseStream).ReadToEnd();
}
catch (WebException wex)
{
TwitterStatus status = TwitterStatus.GeneralError; ;
if (wex.Status == WebExceptionStatus.ProtocolError)
{
switch(((HttpWebResponse)wex.Response).StatusCode)
{
case HttpStatusCode.BadRequest:
status = TwitterStatus.BadRequest;
break;
case HttpStatusCode.Unauthorized:
status = TwitterStatus.Unauthorized;
break;
case HttpStatusCode.NotFound:
status = TwitterStatus.FileNotFound;
break;
case HttpStatusCode.NotAcceptable:
status = TwitterStatus.NotAcceptable;
break;
default:
status = TwitterStatus.GeneralError;
break;
}
}
return new TwitterResponse<string>()
{
Status = status,
ObjectResponse = String.Empty
};
}
return new TwitterResponse<string>()
{
Status = TwitterStatus.Success,
ObjectResponse = responseBody
};
}
