/// <summary>
/// Starts the public stream.
/// </summary>
public IAsyncResult StartPublicStream(
StreamStoppedCallback streamErrorCallback,
StatusCreatedCallback statusCreatedCallback,
StatusDeletedCallback statusDeletedCallback,
EventCallback eventCallback,
RawJsonCallback rawJsonCallback = null
)
{
WebRequestBuilder builder;
if (this.Tokens == null)
{
builder = new WebRequestBuilder(new Uri("https://stream.twitter.com/1/statuses/filter.json"), HTTPVerb.POST, true, this.UserAgent, this.NetworkCredentials);
}
else
{
builder = new WebRequestBuilder(new Uri("https://stream.twitter.com/1/statuses/filter.json"), HTTPVerb.POST, this.Tokens, true, this.UserAgent);
}
PrepareStreamOptions(builder);
HttpWebRequest request = builder.PrepareRequest();
this.streamStoppedCallback = streamErrorCallback;
this.statusCreatedCallback = statusCreatedCallback;
this.statusDeletedCallback = statusDeletedCallback;
this.eventCallback = eventCallback;
this.rawJsonCallback = rawJsonCallback;
this.stopReceived = false;
#if SILVERLIGHT
request.AllowReadStreamBuffering = false;
#endif
return(request.BeginGetResponse(StreamCallback, request));
}
/// <summary>
/// Prepares the stream options.
/// </summary>
/// <param name = "builder">The builder.</param>
private void PrepareStreamOptions(WebRequestBuilder builder)
{
if (StreamOptions != null)
{
if (StreamOptions.Count > 0)
{
builder.Parameters.Add("count", StreamOptions.Count.ToString());
}
if (StreamOptions.Follow != null && StreamOptions.Follow.Count > 0)
{
builder.Parameters.Add("follow", string.Join(",", StreamOptions.Follow.ToArray()));
}
if (StreamOptions.Locations != null && StreamOptions.Locations.Count > 0)
{
builder.Parameters.Add("locations",
string.Join(",",
StreamOptions.Locations.Select((x, r) => x.ToString()).ToArray()));
}
if (StreamOptions.Track != null && StreamOptions.Track.Count > 0)
{
builder.Parameters.Add("track", string.Join(",", StreamOptions.Track.ToArray()));
}
builder.UseCompression = StreamOptions.UseCompression;
}
}
/// <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);
}
public void WhenIGetTheCreatedPost()
{
var createdPost = _scenarioContext.PostRapidApiResponse.ParseResponse <BlogPost>();
var getRequest = new WebRequestBuilder($"{ApiRootUrl}/blogPosts/{createdPost.id}")
.WithRequestMethod(HttpMethod.Get)
.Build();
_scenarioContext.GetRapidApiResponse = ApiRequestProcessor.Call(getRequest);
}
private void CreateNewBlogPost(Table table)
{
var blogPost = table.CreateInstance <BlogPost>();
var createBlogPostRequest = new WebRequestBuilder($"{ApiRootUrl}/blogPosts")
.WithRequestMethod(HttpMethod.Post)
.WithRequestData(blogPost)
.Build();
_scenarioContext.PostRapidApiResponse = ApiRequestProcessor.Call(createBlogPostRequest);
}
public override async Task <ResponseResult <TResponseParser> > Execute()
{
this.CheckSettings();
if (this.webRequestBuilder == null)
{
this.webRequestBuilder = new EwsWebRequestBuilder();
}
string xml = this.Parameters.BuildXml(this.CommandName);
return(await this.SendRequestAsync(xml, this.Settings.Username, this.Settings.Password));
}
public void GivenIHaveAuthenticatedWithTheApplication()
{
var authEndpoint = "AUTH_ENDPOINT";
var clientId = "CLIENTID";
var clientSecret = "CLIENT_SECRET";
var url = $"{authEndpoint}?clientId={clientId}&clientSecret={clientSecret}";
var webRequest = new WebRequestBuilder(url)
.Build();
_scenarioContext.AuthResponse = ApiRequestProcessor.Call(webRequest);
}
/// <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);
}
/// <summary>
/// Starts the user stream.
/// </summary>
public IAsyncResult StartUserStream(
InitUserStreamCallback friendsCallback,
StreamStoppedCallback streamStoppedCallback,
StatusCreatedCallback statusCreatedCallback,
StatusDeletedCallback statusDeletedCallback,
DirectMessageCreatedCallback directMessageCreatedCallback,
DirectMessageDeletedCallback directMessageDeletedCallback,
EventCallback eventCallback,
RawJsonCallback rawJsonCallback = null
)
{
if (request != null)
{
throw new InvalidOperationException("Stream is already open");
}
WebRequestBuilder builder = new WebRequestBuilder(new Uri("https://userstream.twitter.com/1.1/user.json"),
HTTPVerb.GET, Tokens, userAgent);
#if !SILVERLIGHT
builder.Proxy = Proxy;
#endif
PrepareStreamOptions(builder);
if (StreamOptions != null && StreamOptions is UserStreamOptions)
{
if ((StreamOptions as UserStreamOptions).AllReplies)
{
builder.Parameters.Add("replies", "all");
}
}
request = builder.PrepareRequest();
this.friendsCallback = friendsCallback;
this.streamStoppedCallback = streamStoppedCallback;
this.statusCreatedCallback = statusCreatedCallback;
this.statusDeletedCallback = statusDeletedCallback;
this.directMessageCreatedCallback = directMessageCreatedCallback;
this.directMessageDeletedCallback = directMessageDeletedCallback;
this.eventCallback = eventCallback;
this.rawJsonCallback = rawJsonCallback;
stopReceived = false;
#if SILVERLIGHT
request.AllowReadStreamBuffering = false;
#else
request.Timeout = 10000;
#endif
return(request.BeginGetResponse(StreamCallback, request));
}
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>
/// Starts the sample stream.
/// </summary>
public IAsyncResult StartSampleStream(
StreamStoppedCallback streamStoppedCallback,
StatusCreatedCallback statusCreatedCallback,
StatusDeletedCallback statusDeletedCallback,
EventCallback eventCallback,
RawJsonCallback rawJsonCallback = null
)
{
if (request != null)
{
throw new InvalidOperationException("Stream is already open");
}
WebRequestBuilder builder;
if (Tokens == null)
{
builder = new WebRequestBuilder(new Uri("https://stream.twitter.com/1.1/statuses/sample.json"),
HTTPVerb.POST, userAgent, NetworkCredentials);
}
else
{
builder = new WebRequestBuilder(new Uri("https://stream.twitter.com/1.1/statuses/sample.json"),
HTTPVerb.POST, Tokens, userAgent);
}
#if !SILVERLIGHT
builder.Proxy = Proxy;
#endif
PrepareStreamOptions(builder);
request = builder.PrepareRequest();
this.streamStoppedCallback = streamStoppedCallback;
this.statusCreatedCallback = statusCreatedCallback;
this.statusDeletedCallback = statusDeletedCallback;
this.eventCallback = eventCallback;
this.rawJsonCallback = rawJsonCallback;
stopReceived = false;
#if SILVERLIGHT
request.AllowReadStreamBuffering = false;
#endif
return(request.BeginGetResponse(StreamCallback, request));
}
/// <summary>
/// Starts the user stream.
/// </summary>
public async void StartUserStream(
InitUserStreamCallback friendsCallback,
StreamStoppedCallback streamStoppedCallback,
StatusCreatedCallback statusCreatedCallback,
StatusDeletedCallback statusDeletedCallback,
DirectMessageCreatedCallback directMessageCreatedCallback,
DirectMessageDeletedCallback directMessageDeletedCallback,
EventCallback eventCallback,
RawJsonCallback rawJsonCallback = null
)
{
if (request != null)
{
throw new InvalidOperationException("Stream is already open");
}
WebRequestBuilder builder = new WebRequestBuilder(new Uri("https://userstream.twitter.com/2/user.json"),
HttpMethod.Get, Tokens, userAgent);
PrepareStreamOptions(builder);
if (StreamOptions != null && StreamOptions is UserStreamOptions)
{
if ((StreamOptions as UserStreamOptions).AllReplies)
{
builder.Parameters.Add("replies", "all");
}
}
request = await builder.PrepareRequestAsync();
this.friendsCallback = friendsCallback;
this.streamStoppedCallback = streamStoppedCallback;
this.statusCreatedCallback = statusCreatedCallback;
this.statusDeletedCallback = statusDeletedCallback;
this.directMessageCreatedCallback = directMessageCreatedCallback;
this.directMessageDeletedCallback = directMessageDeletedCallback;
this.eventCallback = eventCallback;
this.rawJsonCallback = rawJsonCallback;
stopReceived = false;
//request.DefaultRequestHeaders.Timeout = 10000;
return(client.GetAsync(request)); ..BeginGetResponse(StreamCallback, request);
/// <summary>
/// Starts the user stream.
/// </summary>
public IAsyncResult StartUserStream(
InitUserStreamCallback friendsCallback,
StreamStoppedCallback streamErrorCallback,
StatusCreatedCallback statusCreatedCallback,
StatusDeletedCallback statusDeletedCallback,
DirectMessageCreatedCallback directMessageCreatedCallback,
DirectMessageDeletedCallback directMessageDeletedCallback,
EventCallback eventCallback,
RawJsonCallback rawJsonCallback = null
)
{
WebRequestBuilder builder = new WebRequestBuilder(new Uri("https://userstream.twitter.com/2/user.json"), HTTPVerb.GET, this.Tokens, true, this.UserAgent);
PrepareStreamOptions(builder);
if (this.StreamOptions != null && this.StreamOptions is UserStreamOptions)
{
if ((this.StreamOptions as UserStreamOptions).AllReplies)
{
builder.Parameters.Add("replies", "all");
}
}
HttpWebRequest request = builder.PrepareRequest();
this.friendsCallback = friendsCallback;
this.streamStoppedCallback = streamErrorCallback;
this.statusCreatedCallback = statusCreatedCallback;
this.statusDeletedCallback = statusDeletedCallback;
this.directMessageCreatedCallback = directMessageCreatedCallback;
this.directMessageDeletedCallback = directMessageDeletedCallback;
this.eventCallback = eventCallback;
this.rawJsonCallback = rawJsonCallback;
this.stopReceived = false;
#if SILVERLIGHT
request.AllowReadStreamBuffering = false;
#endif
return(request.BeginGetResponse(StreamCallback, request));
}
public static void WebRequestBuilderParts()
{
WebRequestBuilder builder = new WebRequestBuilder(
new Uri("http://example.com/endpoint"),
HTTPVerb.GET,
new OAuthTokens
{
ConsumerKey = "key",
ConsumerSecret = "518F1B7B4C2F855EFF3DEFDAF1311",
AccessToken = "token",
AccessTokenSecret = "A6FE4462BAA8C3ADEA7D9E3BCD5BB"
}
);
// Manually add our values
builder.Parameters.Add("oauth_version", "1.0");
builder.Parameters.Add("oauth_nonce", "5565373");
builder.Parameters.Add("oauth_timestamp", "1283303184");
builder.Parameters.Add("oauth_signature_method", "HMAC-SHA1");
builder.Parameters.Add("oauth_consumer_key", "49A8746B34B83CA13D1B9DACFD251");
builder.Parameters.Add("oauth_consumer_secret", "518F1B7B4C2F855EFF3DEFDAF1311");
builder.Parameters.Add("oauth_token", "8B163EC93574682CFF3FD6B45BD55");
builder.Parameters.Add("oauth_token_secret", "A6FE4462BAA8C3ADEA7D9E3BCD5BB");
string signature = builder.GenerateSignature();
Assert.AreEqual(signature, "ndQStX289rIMyZR5dErSinLK/bQ=");
builder.Parameters.Add("text", "this is a test http://example.com/test?key=value&key%202");
signature = builder.GenerateSignature();
Assert.AreEqual(signature, "MUUsZ/iV/FXxBRPdyxRkNKqEShw=");
builder.Verb = HTTPVerb.POST;
signature = builder.GenerateSignature();
Assert.AreEqual(signature, "wtbXMN5BwtH8r2/G/Rwqdp7HMnU=");
}
/// <summary>
/// Starts the public stream.
/// </summary>
public IAsyncResult StartPublicStream(
StreamStoppedCallback streamStoppedCallback,
StatusCreatedCallback statusCreatedCallback,
StatusDeletedCallback statusDeletedCallback,
EventCallback eventCallback,
RawJsonCallback rawJsonCallback = null
)
{
if (request != null)
{
throw new InvalidOperationException("Stream is already open");
}
WebRequestBuilder builder;
if (Tokens == null)
builder = new WebRequestBuilder(new Uri("https://stream.twitter.com/1/statuses/filter.json"),
HTTPVerb.POST, userAgent, NetworkCredentials);
else
builder = new WebRequestBuilder(new Uri("https://stream.twitter.com/1/statuses/filter.json"),
HTTPVerb.POST, Tokens, userAgent);
PrepareStreamOptions(builder);
request = builder.PrepareRequest();
this.streamStoppedCallback = streamStoppedCallback;
this.statusCreatedCallback = statusCreatedCallback;
this.statusDeletedCallback = statusDeletedCallback;
this.eventCallback = eventCallback;
this.rawJsonCallback = rawJsonCallback;
stopReceived = false;
#if SILVERLIGHT
request.AllowReadStreamBuffering = false;
#endif
return request.BeginGetResponse(StreamCallback, request);
}
/// <summary>
/// Starts the user stream.
/// </summary>
public IAsyncResult StartUserStream(
InitUserStreamCallback friendsCallback,
StreamStoppedCallback streamStoppedCallback,
StatusCreatedCallback statusCreatedCallback,
StatusDeletedCallback statusDeletedCallback,
DirectMessageCreatedCallback directMessageCreatedCallback,
DirectMessageDeletedCallback directMessageDeletedCallback,
EventCallback eventCallback,
RawJsonCallback rawJsonCallback = null
)
{
if (request != null)
{
throw new InvalidOperationException("Stream is already open");
}
WebRequestBuilder builder = new WebRequestBuilder(new Uri("https://userstream.twitter.com/2/user.json"),
HTTPVerb.GET, Tokens, userAgent);
PrepareStreamOptions(builder);
if (StreamOptions != null && StreamOptions is UserStreamOptions)
{
if ((StreamOptions as UserStreamOptions).AllReplies)
builder.Parameters.Add("replies", "all");
}
request = builder.PrepareRequest();
this.friendsCallback = friendsCallback;
this.streamStoppedCallback = streamStoppedCallback;
this.statusCreatedCallback = statusCreatedCallback;
this.statusDeletedCallback = statusDeletedCallback;
this.directMessageCreatedCallback = directMessageCreatedCallback;
this.directMessageDeletedCallback = directMessageDeletedCallback;
this.eventCallback = eventCallback;
this.rawJsonCallback = rawJsonCallback;
stopReceived = false;
#if SILVERLIGHT
request.AllowReadStreamBuffering = false;
#else
request.Timeout = 10000;
#endif
return request.BeginGetResponse(StreamCallback, request);
}
public async Task <SystemNetHttpRequestResult> SendRequestAsync(string url, HttpMethod method, string contentType, string requestBody, byte[] requestBytes, Dictionary <string, string> headers, NetworkCredential credentials)
{
var filter = new HttpBaseProtocolFilter
{
AutomaticDecompression = true,
AllowAutoRedirect = true,
AllowUI = false
};
if (filter.IgnorableServerCertificateErrors != null)
{
filter.IgnorableServerCertificateErrors.Add(ChainValidationResult.Untrusted);
filter.IgnorableServerCertificateErrors.Add(ChainValidationResult.InvalidName);
}
// use this to make sure we don't have weird behavior where the app caches credentials for way too long
// the real fix seems to be using a new API introduced in 14295 but that's not the version that is targeted today
// see: http://stackoverflow.com/questions/30731424/how-to-stop-credential-caching-on-windows-web-http-httpclient
filter.CookieUsageBehavior = HttpCookieUsageBehavior.NoCookies;
if (credentials != null)
{
filter.ServerCredential = new PasswordCredential("2Day", credentials.UserName, credentials.Password);
}
else
{
filter.ServerCredential = null;
}
var client = new HttpClient(filter);
if (headers != null)
{
foreach (var header in headers)
{
client.DefaultRequestHeaders.Add(header.Key, header.Value);
}
}
var request = new Windows.Web.Http.HttpRequestMessage(method.ToWindowsHttp(), SafeUri.Get(url));
HttpRequestMessage systemNetRequest = request.ToSystemHttp();
if (requestBody != null)
{
if (method != HttpMethod.Post)
{
throw new NotSupportedException("Request body must use POST method");
}
var arrayContent = new HttpBufferContent(requestBytes.AsBuffer());
if (!string.IsNullOrWhiteSpace(contentType))
{
arrayContent.Headers.ContentType = new HttpMediaTypeHeaderValue(contentType);
}
if (method == HttpMethod.Post)
{
request.Content = arrayContent;
}
}
WebRequestBuilder.TraceRequest(systemNetRequest, requestBody);
CancellationTokenSource timeoutCancellationToken = new CancellationTokenSource(TimeSpan.FromSeconds(30));
Windows.Web.Http.HttpResponseMessage response = await client.SendRequestAsync(request).AsTask(timeoutCancellationToken.Token);
client.Dispose();
HttpResponseMessage systemNetResponse = await response.ToWindowsHttp(systemNetRequest);
return(new SystemNetHttpRequestResult
{
Request = systemNetRequest,
Response = systemNetResponse
});
}
public void ProcessRequest(HttpContext context)
{
StringBuilder log = new StringBuilder();
string screenName = "";
try
{
string query = "";
UriBuilder urlBuilder = new UriBuilder("https://api.twitter.com/" + context.Server.UrlDecode(context.Request.QueryString["query"]));
// Adds query strings to the url.
// some headers may not be copied because they can't be used with clients other than twitter
foreach (var queryString in context.Request.QueryString.AllKeys)
{
switch (queryString)
{
case "u":
case "p":
case "query":
case "earned":
case "pc":
break;
default:
query += string.Format("&{0}={1}", queryString, context.Request.QueryString[queryString]);
break;
}
}
if (query.Length > 1)
{
query = query.Substring(1);
}
urlBuilder.Query = query;
log.AppendLine(query);
log.AppendLine("URL: " + urlBuilder.Uri.ToString());
OAuthTokens tokens = new OAuthTokens();
tokens.ConsumerKey = ConfigurationManager.AppSettings["TwitterConsumerKey"];
tokens.ConsumerSecret = ConfigurationManager.AppSettings["TwitterConsumerSecret"];
JToken accessToken;
String userFileName = context.Server.MapPath("/App_Data/Users/" + context.Request.QueryString["u"] + "." + context.Request.QueryString["p"]);
if (File.Exists(userFileName))
{
using (StreamReader str = new StreamReader(userFileName))
{
accessToken = JObject.Parse(str.ReadToEnd());
;
}
tokens.AccessToken = (string)accessToken.SelectToken("AccessToken");
tokens.AccessTokenSecret = (string)accessToken.SelectToken("AccessSecret");
screenName = (string)accessToken.SelectToken("ScreenName");
log.AppendLine("User FOUND!");
}
else
{
log.AppendLine("User NOT FOUND");
context.Response.StatusCode = 404;
return;
}
//check if the request is xAuth, if it is, simulates the xAuth result for fooling Twitter for iPhone.
if (context.Request.QueryString["query"].Contains("oauth/access_token"))
{
string xAuthResponse = string.Format("oauth_token={0}&oauth_token_secret={1}&user_id={2}&screen_name={3}&x_auth_expires=0",
(string)accessToken.SelectToken("AccessToken"),
(string)accessToken.SelectToken("AccessSecret"),
(string)accessToken.SelectToken("UserId"),
(string)accessToken.SelectToken("ScreenName"));
context.Response.Write(xAuthResponse);
screenName = (string)accessToken.SelectToken("ScreenName");
return;
}
HTTPVerb verb = HTTPVerb.GET;
switch (context.Request.HttpMethod)
{
case "GET":
verb = HTTPVerb.GET;
break;
case "POST":
verb = HTTPVerb.POST;
break;
case "DELETE":
verb = HTTPVerb.DELETE;
break;
}
if (context.Request.Headers["Authorization"] == null)
{
tokens = null;
log.AppendLine("Request NOT authenticated");
}
WebRequestBuilder webreq = new WebRequestBuilder(urlBuilder.Uri, verb, tokens);
webreq.Multipart = (context.Request.ContentType.Contains("multipart"));
if (verb != HTTPVerb.GET)
{
// adds body parameters to request
foreach (var key in context.Request.Form.AllKeys)
{
webreq.Parameters.Add(key, context.Request.Form[key]);
}
foreach (var fileKey in context.Request.Files.AllKeys)
{
webreq.Parameters.Add(fileKey, context.Request.Form[fileKey]);
}
}
ServicePointManager.Expect100Continue = false;
HttpWebRequest req = webreq.PrepareRequest();
try
{
HttpWebResponse resp = (HttpWebResponse)req.GetResponse();
log.AppendLine("get Response");
StreamReader strReader = new StreamReader(resp.GetResponseStream());
String response = strReader.ReadToEnd();
if (ConfigurationManager.AppSettings["debugMode"] == "true")
{
log.AppendLine(response);
}
// replaces images url to use TwiX to load them
response = Regex.Replace(response, @"(((http:\\/\\/www)|(http:\\/\\/)|(https:\\/\\/www)|(https:\\/\\/)|(www))[-a-zA-Z0-9@:%_\\\+.~#?&//=]+)\.(jpg|jpeg|gif|png|bmp|tiff|tga|svg)", delegate(Match match)
{
string v = match.ToString();
return(ConfigurationManager.AppSettings["baseUrl"] + "image/" + shFunctions.encryptBase64Url(DES.Encrypt(v.Replace(@"\/", "/").Replace("_normal", ""), shFunctions.key) + ".jpg"));
});
strReader.Close();
context.Response.ClearContent();
context.Response.Write(response);
}
catch (WebException webex)
{
if (webex.Status == WebExceptionStatus.ProtocolError)
{
context.Response.StatusCode = (int)((HttpWebResponse)webex.Response).StatusCode;
}
log.AppendLine("ERROR: " + webex.Message);
return;
}
}
catch (Exception ee) {
log.AppendLine("Error: " + ee.Message);
log.AppendLine("stack: " + ee.StackTrace);
}
if (ConfigurationManager.AppSettings["log"] == "true")
{
writeLogToFile(log.ToString(), screenName, context.Request.HttpMethod, context);
}
//throw new Exception(context.Request.QueryString.ToString());
}
/// <summary>
/// Executes the command.
/// </summary>
/// <returns>The results of the command.</returns>
public async Task <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 (CustomAttributeData attribute in System.Reflection.IntrospectionExtensions.GetTypeInfo(this.GetType()).CustomAttributes)
{
if (attribute.AttributeType == typeof(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.AttributeType == typeof(RateLimitedAttribute))
{
//Get the rate limiting status
if ((await Account.RateLimitStatusAsync(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 = null;
AccessLevel accessLevel;
string responseData = null;
HttpResponseMessage response = null;
try
{
WebRequestBuilder requestBuilder = new WebRequestBuilder(this.Uri, this.Verb, this.Tokens)
{
Multipart = this.Multipart
};
foreach (var item in queryParameters)
{
requestBuilder.Parameters.Add(item.Key, item.Value);
}
try
{
response = await requestBuilder.ExecuteRequestAsync();
}
catch
{
;
}
if (response == null)
{
twitterResponse.Result = RequestResult.Unknown;
return(twitterResponse);
}
responseData = await response.Content.ReadAsStringAsync(); // ConversionUtility.ReadStream(await response.Content.ReadAsStreamAsync());
twitterResponse.Content = responseData; // Encoding.UTF8.GetString(responseData, 0, responseData.Length);
twitterResponse.RequestUrl = requestBuilder.RequestUri.AbsoluteUri;
// Parse the rate limiting HTTP Headers
rateLimiting = ParseRateLimitHeaders(response.Headers);
// Parse Access Level
accessLevel = ParseAccessLevel(response.Headers);
// Lookup the status code and set the status accordingly
SetStatusCode(twitterResponse, response.StatusCode, rateLimiting);
twitterResponse.RateLimiting = rateLimiting;
twitterResponse.AccessLevel = accessLevel;
response.EnsureSuccessStatusCode();
}
catch (HttpRequestException wex)
{
// Lookup the status code and set the status accordingly
SetStatusCode(twitterResponse, response.StatusCode, rateLimiting);
twitterResponse.ErrorMessage = wex.Message;
// 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.
}
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 jse)
{
twitterResponse.ErrorMessage = String.Format("Unable to parse JSON: {0}", jse.Message);
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);
}
public void SetUp()
{
sys = new Mock <Sys>();
sut = new WebRequestBuilder(sys.Object, "{key}/{pid}");
}
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>
/// Starts the stream.
/// </summary>
private void StartStream(string streamUri)
{
WebRequestBuilder builder = new WebRequestBuilder(new Uri(streamUri), HTTPVerb.GET, this.Tokens);
HttpWebRequest request;
request = builder.PrepareRequest();
request.UserAgent = userAgent;
request.BeginGetResponse(
ar =>
{
var req = (WebRequest)ar.AsyncState;
// TODO: Add exception handling: EndGetResponse could throw
using (var response = req.EndGetResponse(ar))
using (var reader = new StreamReader(response.GetResponseStream()))
{
// This loop goes as long as twitter is streaming
while (!reader.EndOfStream)
{
// If the calling application has asked to halt the connection, this will abort the connection.
if (this.stopReceived)
{
req.Abort();
OnStreamingStopped(StopReasons.StoppedByRequest, "Stop request received");
return;
}
try
{
TwitterStatus resultObject = Twitterizer.Core.SerializationHelper<TwitterStatus>.Deserialize(
Encoding.UTF8.GetBytes(reader.ReadLine()));
if (resultObject != null && resultObject.Id > 0 && this.OnStatusReceived != null)
{
this.OnStatusReceived(resultObject);
}
}
catch (System.Runtime.Serialization.SerializationException)
{
}
}
}
},
request);
}
/// <summary>
/// Starts the public stream.
/// </summary>
public IAsyncResult StartPublicStream(
StreamStoppedCallback streamErrorCallback,
StatusCreatedCallback statusCreatedCallback,
StatusDeletedCallback statusDeletedCallback,
EventCallback eventCallback,
RawJsonCallback rawJsonCallback = null
)
{
WebRequestBuilder builder;
if (this.Tokens == null)
builder = new WebRequestBuilder(new Uri("https://stream.twitter.com/1/statuses/filter.json"), HTTPVerb.POST, true, this.UserAgent, this.NetworkCredentials);
else
builder = new WebRequestBuilder(new Uri("https://stream.twitter.com/1/statuses/filter.json"), HTTPVerb.POST, this.Tokens, true, this.UserAgent);
PrepareStreamOptions(builder);
HttpWebRequest request = builder.PrepareRequest();
this.streamStoppedCallback = streamErrorCallback;
this.statusCreatedCallback = statusCreatedCallback;
this.statusDeletedCallback = statusDeletedCallback;
this.eventCallback = eventCallback;
this.rawJsonCallback = rawJsonCallback;
this.stopReceived = false;
#if SILVERLIGHT
request.AllowReadStreamBuffering = false;
#endif
return request.BeginGetResponse(StreamCallback, request);
}
/// <summary>
/// Starts the user stream.
/// </summary>
public async void StartUserStream(
InitUserStreamCallback friendsCallback,
StreamStoppedCallback streamStoppedCallback,
StatusCreatedCallback statusCreatedCallback,
StatusDeletedCallback statusDeletedCallback,
DirectMessageCreatedCallback directMessageCreatedCallback,
DirectMessageDeletedCallback directMessageDeletedCallback,
EventCallback eventCallback,
RawJsonCallback rawJsonCallback = null
)
{
if (request != null)
{
throw new InvalidOperationException("Stream is already open");
}
WebRequestBuilder builder = new WebRequestBuilder(new Uri("https://userstream.twitter.com/2/user.json"),
HttpMethod.Get, Tokens, userAgent);
PrepareStreamOptions(builder);
if (StreamOptions != null && StreamOptions is UserStreamOptions)
{
if ((StreamOptions as UserStreamOptions).AllReplies)
builder.Parameters.Add("replies", "all");
}
request = await builder.PrepareRequestAsync();
this.friendsCallback = friendsCallback;
this.streamStoppedCallback = streamStoppedCallback;
this.statusCreatedCallback = statusCreatedCallback;
this.statusDeletedCallback = statusDeletedCallback;
this.directMessageCreatedCallback = directMessageCreatedCallback;
this.directMessageDeletedCallback = directMessageDeletedCallback;
this.eventCallback = eventCallback;
this.rawJsonCallback = rawJsonCallback;
stopReceived = false;
//request.DefaultRequestHeaders.Timeout = 10000;
return client.GetAsync(request);..BeginGetResponse(StreamCallback, request);
return null;
}
/// <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
};
}
/// <summary>
/// Prepares the stream options.
/// </summary>
/// <param name="builder">The builder.</param>
private void PrepareStreamOptions(WebRequestBuilder builder)
{
if (this.StreamOptions != null)
{
if (this.StreamOptions.Count > 0)
builder.Parameters.Add("count", this.StreamOptions.Count.ToString());
if (this.StreamOptions.Follow != null && this.StreamOptions.Follow.Count > 0)
builder.Parameters.Add("follow", string.Join(",", this.StreamOptions.Follow.ToArray()));
if (this.StreamOptions.Locations != null && this.StreamOptions.Locations.Count > 0)
builder.Parameters.Add("locations", string.Join(",", this.StreamOptions.Locations.Select((x, r) => x.ToString()).ToArray()));
if (this.StreamOptions.Track != null && this.StreamOptions.Track.Count > 0)
builder.Parameters.Add("track", string.Join(",", this.StreamOptions.Track.ToArray()));
}
}
/// <summary>
/// Prepares the stream options.
/// </summary>
/// <param name = "builder">The builder.</param>
private void PrepareStreamOptions(WebRequestBuilder builder)
{
if (StreamOptions != null)
{
if (StreamOptions.Count > 0)
builder.Parameters.Add("count", StreamOptions.Count.ToString());
if (StreamOptions.Follow != null && StreamOptions.Follow.Count > 0)
builder.Parameters.Add("follow", string.Join(",", StreamOptions.Follow.ToArray()));
if (StreamOptions.Locations != null && StreamOptions.Locations.Count > 0)
builder.Parameters.Add("locations",
string.Join(",",
StreamOptions.Locations.Select((x, r) => x.ToString()).ToArray()));
if (StreamOptions.Track != null && StreamOptions.Track.Count > 0)
builder.Parameters.Add("track", string.Join(",", StreamOptions.Track.ToArray()));
builder.UseCompression = StreamOptions.UseCompression;
#if !SILVERLIGHT
if (this.StreamOptions != null)
builder.Proxy = this.StreamOptions.Proxy;
#endif
}
}
/// <summary>
/// Starts the user stream.
/// </summary>
public IAsyncResult StartUserStream(
InitUserStreamCallback friendsCallback,
StreamStoppedCallback streamErrorCallback,
StatusCreatedCallback statusCreatedCallback,
StatusDeletedCallback statusDeletedCallback,
DirectMessageCreatedCallback directMessageCreatedCallback,
DirectMessageDeletedCallback directMessageDeletedCallback,
EventCallback eventCallback,
RawJsonCallback rawJsonCallback = null
)
{
WebRequestBuilder builder = new WebRequestBuilder(new Uri("https://userstream.twitter.com/2/user.json"), HTTPVerb.GET, this.Tokens, true, this.UserAgent);
PrepareStreamOptions(builder);
if (this.StreamOptions != null && this.StreamOptions is UserStreamOptions)
{
if ((this.StreamOptions as UserStreamOptions).AllReplies)
builder.Parameters.Add("replies", "all");
}
HttpWebRequest request = builder.PrepareRequest();
this.friendsCallback = friendsCallback;
this.streamStoppedCallback = streamErrorCallback;
this.statusCreatedCallback = statusCreatedCallback;
this.statusDeletedCallback = statusDeletedCallback;
this.directMessageCreatedCallback = directMessageCreatedCallback;
this.directMessageDeletedCallback = directMessageDeletedCallback;
this.eventCallback = eventCallback;
this.rawJsonCallback = rawJsonCallback;
this.stopReceived = false;
#if SILVERLIGHT
request.AllowReadStreamBuffering = false;
#endif
return request.BeginGetResponse(StreamCallback, request);
}
/// <summary>
/// Starts the user stream.
/// </summary>
public void StartUserStream()
{
WebRequestBuilder builder = new WebRequestBuilder(new Uri("https://userstream.twitter.com/2/user.json"), HTTPVerb.GET, this.Tokens);
HttpWebRequest request = builder.PrepareRequest();
request.KeepAlive = true;
//request.UserAgent = userAgent;
request.BeginGetResponse(StreamCallback, request);
}
/// <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);
}
protected EwsCommandBase(EwsRequestParameter <TRequestBuilder> parameters, WebRequestBuilder webRequestBuilder)
: base(parameters)
{
this.webRequestBuilder = webRequestBuilder;
}
