/// <summary> /// Method allowing to request data from an URL targeting a specific timeframe (using since_id and max_id parameters). /// Since_id must be included in the method_url parameter. /// Iterate over the different pages of results for this time frame. /// For each iteration, memorize the maximum of all the object ids and reuse it in the URL to request objects for the /// next iteration. Also, handle each object retrieved with the ObjectResponseDelegate given in parameter. /// </summary> /// <param name="url">Url from Twitter Api to query. Can include a since_id parameter</param> /// <param name="sinceMaxDelegate">delegate handling the objects retrieved from the Twitter API</param> /// <param name="webExceptionHandlerDelegate">Handle exceptions occuring upon request to the Twitter API</param> public void ExecuteSinceMaxQuery( string url, ObjectResponseDelegate sinceMaxDelegate, WebExceptionHandlingDelegate webExceptionHandlerDelegate = null) { string updated_method_url = url; long maxId = Int64.MaxValue; int startLoop = 1; int nbItemsReceived = 0; ObjectResponseDelegate objectDelegate = delegate(Dictionary <string, object> o) { ++nbItemsReceived; long itemId = (long)o["id"]; if (maxId > itemId) { maxId = itemId; } if (sinceMaxDelegate != null) { sinceMaxDelegate(o); } }; while (startLoop != nbItemsReceived) { try { dynamic responseObject = ExecuteGETQuery(updated_method_url, objectDelegate, webExceptionHandlerDelegate); if (responseObject == null) { break; } if (startLoop == nbItemsReceived) { break; } // Request the following items starting from the oldest item handled updated_method_url = String.Format(url + "&max_id={0}", maxId); // Avoid to start from the last tweet already handled when we will go over the next loop startLoop = 1; } catch (WebException wex) { if (ExceptionHandler != null) { ExceptionHandler(wex); } else { throw; } } } }
public Dictionary <string, object>[] ExecutePOSTQueryReturningCollectionOfObjects( string url, ObjectResponseDelegate objectHandler = null, WebExceptionHandlingDelegate exceptionHandler = null) { return(ExecuteQuery(url, HttpMethod.POST, objectHandler, exceptionHandler)); }
public ITweet PublishRetweet() { if (_id == null || !IsTweetPublished || IsTweetDestroyed) { return(null); } Tweet result = null; string query = String.Format(Resources.Tweet_PublishRetweet, _id); WebExceptionHandlingDelegate wex = delegate(WebException exception) { if (exception.GetWebExceptionStatusNumber() == 403) { result = null; } }; ObjectResponseDelegate objectDelegate = delegate(Dictionary <string, object> responseObject) { result = new Tweet(responseObject, _shareTokenWithChild ? _token : null); }; _token.ExecutePOSTQuery(query, objectDelegate, wex); return(result); }
public bool Destroy(IToken token = null, bool getUserInfo = false) { token = GetQueryToken(token); // We cannot destroy a tweet that has not been published // We cannot destroy a tweet that has already been destroyed if (!_isTweetPublished || _isTweetDestroyed || _id == null || token == null) { return(false); } bool result = true; // If a WebException occurs, the deletion has not been performed WebExceptionHandlingDelegate wex = delegate { result = false; }; string destroyQuery = String.Format(Resources.Tweet_Destroy, _id); token.ExecutePOSTQuery(destroyQuery, null, wex); _isTweetDestroyed = result; return(result); }
/// <summary> /// Get the Home timeline of the current user /// </summary> /// <param name="queryToken">Token to be used to perform the query</param> /// <param name="count">Maximum number of Tweet received</param> /// <param name="trim_user">User information sent with the Tweet</param> /// <param name="exclude_replies">When true the replies to tweet are not retrieved</param> /// <param name="since_id">Minimum Id of tweet to receive</param> /// <param name="max_id">Maximum Id of twee to receive</param> /// <param name="wex">Exception handler</param> /// <returns>Tweets from the Home timeline</returns> private List <ITweet> GetHomeTimeLine( IToken queryToken, int count, bool trim_user, bool exclude_replies, int?since_id, int?max_id, WebExceptionHandlingDelegate wex) { if (queryToken == null) { Console.WriteLine("Token must be specified"); return(null); } string query; if (since_id == null && max_id == null) { query = String.Format(Resources.TokenUser_GetLatestHomeTimeline, count, trim_user, exclude_replies); } else { query = String.Format(Resources.TokenUser_GetHomeTimeline, count, trim_user, exclude_replies, since_id, max_id); } return(ResultGenerator.GetTweets(queryToken, query, null, wex)); }
/// <summary> /// Request the list of direct message from Twitter using the token and the URL given in parameter /// Handle the exception when the token represents a user who did not authorize the application to get the direct messages /// </summary> /// <param name="token"></param> /// <param name="url"></param> /// <param name="directMessageDelegate"></param> /// <returns>The list of messages retrieved from the Twitter API</returns> private List <IMessage> GetDirectMessages(IToken token, string url, ObjectCreatedDelegate <IMessage> directMessageDelegate = null) { token = GetQueryToken(token); if (token == null || url == null) { throw new ArgumentException("token or request url is null"); } WebExceptionHandlingDelegate webExceptionDelegate = delegate(WebException wex) { int?wexStatusNumber = ExceptionUtils.GetWebExceptionStatusNumber(wex); if (wexStatusNumber == null) { throw wex; } switch (wexStatusNumber) { case 403: Exception e = new Exception("Not enough permission to access direct messages. " + "Update the application access level and ask the user to reauthorize it."); throw e; default: throw wex; } }; return(ResultGenerator.GetMessages(token, url, directMessageDelegate, webExceptionDelegate)); }
/// <summary> /// Update the exception handler attribute with the 3rd parameter /// Get the list of users matching the Twitter request url (contributors or contributees) /// </summary> /// <param name="token"> Current user token to access the Twitter API</param> /// <param name="url">Twitter requets URL</param> /// <param name="exceptionHandlerDelegate">Delegate method to handle Twitter request exceptions</param> /// <returns>Null if the token parameter is null or if the Twitter request fails. A list of users otherwise (contributors or contributees).</returns> private List <IUser> GetContributionObjects(IToken token, String url, WebExceptionHandlingDelegate exceptionHandlerDelegate = null) { token = GetQueryToken(token); if (token == null) { Console.WriteLine("User's token is required"); return(null); } List <IUser> result = new List <IUser>(); ObjectResponseDelegate objectDelegate = delegate(Dictionary <string, object> responseObject) { if (responseObject != null) { result.Add(new User(responseObject)); } }; token.ExecuteGETQuery(url, objectDelegate, exceptionHandlerDelegate); return(result); }
// Execute a generic simple query public virtual string ExecuteQuery( string url, HttpMethod httpMethod, WebExceptionHandlingDelegate exceptionHandler) { return(ExecuteQueryWithSpecificParameters(url, httpMethod, exceptionHandler, GenerateParameters())); }
/// <summary> /// Reinitialize the list of ids of the users blocked by the current user if required by the boolean parameter. /// Retrieve information about the users blocked by the current user from the Twitter API. /// </summary> /// <param name="blockedUsersQuery">Request to send to the Twitter API</param> /// <param name="del">delegate that will handle the data sent in the Twitter API's response</param> /// <param name="createBlockedUsersIds">True by default. Update the attribute _blocked_users_ids if this parameter is true</param> /// <returns>Null if there is no valid token for the current user. Otherwise, The list of ids of the users blocked by the current user.</returns> private void executeBlockedUsersQuery(string blockedUsersQuery, DynamicResponseDelegate del, bool createBlockedUsersIds = true) { // Reset the list of blocked users' ids if required if (createBlockedUsersIds) { _blocked_users_ids = null; _blocked_users_ids = new List <long>(); } WebExceptionHandlingDelegate wexDel = delegate(WebException wex) { int?wexStatusNumber = ExceptionUtils.GetWebExceptionStatusNumber(wex); switch (wexStatusNumber) { // Handle the Exception when the user's token is not valid case 401: throw new WebException("Blocked users can only be accessed using the user's token. Any other token is rejected.", wex); default: throw wex; } }; _token.ExecuteCursorQuery(blockedUsersQuery, 0, Int32.MaxValue, del, wexDel); }
/// <summary> /// Retrieve the timeline of the current user from the Twitter API. /// Update the corresponding attribute if required by the parameter createTimeline. /// Return the timeline of the current user /// </summary> /// <returns>Null if there is no user token, the timeline of the current user otherwise</returns> public List <ITweet> GetUserTimeline(bool createUserTimeline = false, IToken token = null) { // Handle the possible exceptions thrown by the Twitter API WebExceptionHandlingDelegate wexDel = delegate(WebException wex) { // Get the exception status number int?wexStatusNumber = ExceptionUtils.GetWebExceptionStatusNumber(wex); if (wexStatusNumber == null) { throw wex; } switch (wexStatusNumber) { case 400: //Rate limit reached. Throw a new Exception with a specific message throw new WebException("Rate limit is reached", wex); default: //Throw the exception "as-is" throw wex; } }; return(GetUserTimeline(_token, wexDel, createUserTimeline)); }
/// <summary> /// Retrieve the timeline of the current user from the Twitter API. /// Update the corresponding attribute if required by the parameter createTimeline. /// Return the timeline of the current user /// </summary> /// <param name="token">Token of the current user</param> /// <param name="wexDelegate">Handler of WebException thrown by the Twitter API</param> /// <param name="createTimeline">False by default. If true, the attribute _timeline is updated with the result</param> /// <returns>Null if the user token is null, the timeline of the user represented by the token otherwise</returns> private List <ITweet> GetUserTimeline(IToken token, WebExceptionHandlingDelegate wexDelegate = null, bool createTimeline = false) { token = GetQueryToken(token); if (token == null) { Console.WriteLine("Token must be specified"); return(null); } List <ITweet> timeline = new List <ITweet>(); ObjectResponseDelegate tweetDelegate = delegate(Dictionary <string, object> tweetContent) { Tweet t = new Tweet(tweetContent, _shareTokenWithChild ? _token : null); timeline.Add(t); }; token.ExecuteSinceMaxQuery(String.Format(Resources.User_GetUserTimeline, Id), tweetDelegate, wexDelegate); if (createTimeline) { _timeline = timeline; } return(timeline); }
public Dictionary <string, object> ExecutePOSTQuery( string url, ObjectResponseDelegate objectHandler = null, WebExceptionHandlingDelegate exceptionHandler = null) { return(ExecuteQueryWithSingleResponse(url, HttpMethod.POST, objectHandler, exceptionHandler)); }
/// <summary> /// Provide simplified ways to query a list of TwitterObject /// </summary> /// <param name="token">Token to be used</param> /// <param name="queryUrl">URL from which we expect results</param> /// <param name="objectCreatorDelegate">Method to be used to create the expected object</param> /// <param name="objectCreatedDelegate">Delegate to happen after a TwitterObject being created</param> /// <param name="wex">WebException to manage errors</param> /// <returns>Collection of TwitterObject retrieved from the query</returns> public static List <T> GetListOfTwitterObject <T>(IToken token, string queryUrl, ObjectCreatorDelegate <T> objectCreatorDelegate, ObjectCreatedDelegate <T> objectCreatedDelegate = null, WebExceptionHandlingDelegate wex = null) { if (token == null || objectCreatorDelegate == null) { return(null); } List <T> result = new List <T>(); ObjectResponseDelegate objectDelegate = delegate(Dictionary <string, object> objectContent) { T newObject = objectCreatorDelegate(objectContent); if (objectCreatedDelegate != null) { objectCreatedDelegate(newObject); } result.Add(newObject); }; token.ExecuteGETQuery(queryUrl, objectDelegate, wex); return(result); }
public virtual string ExecuteQueryWithSpecificParameters( string url, HttpMethod httpMethod, WebExceptionHandlingDelegate exceptionHandler, IEnumerable <IOAuthQueryParameter> headers) { string result = null; HttpWebRequest httpWebRequest = null; WebResponse response = null; try { httpWebRequest = GetQueryWebRequest(url, httpMethod, headers); httpWebRequest.CachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore); // Opening the connection response = httpWebRequest.GetResponse(); Stream stream = response.GetResponseStream(); _lastHeadersResult = response.Headers; if (stream != null) { // Getting the result StreamReader responseReader = new StreamReader(stream); result = responseReader.ReadLine(); } // Closing the connection response.Close(); httpWebRequest.Abort(); } catch (WebException wex) { if (exceptionHandler != null) { exceptionHandler(wex); } else { throw; } if (response != null) { response.Close(); } if (httpWebRequest != null) { httpWebRequest.Abort(); } } return(result); }
public Dictionary <string, object> ExecuteCursorQuery( string url, long cursor = 0, int max = Int32.MaxValue, DynamicResponseDelegate responseHandler = null, WebExceptionHandlingDelegate exceptionHandler = null) { return(ExecuteCursorQuery(url, ref cursor, max, responseHandler, exceptionHandler)); }
/// <summary> /// Uses the handler for only one query / work also for cursor queries /// </summary> /// <param name="token"></param> static void execute_query_error_handler(IToken token) { WebExceptionHandlingDelegate del = delegate(WebException wex) { Console.WriteLine("You received an execute_query_error!"); Console.WriteLine(wex.Message); }; token.ExecuteGETQuery("https://api.twitter.com/1.1/users/contributors.json?user_id=700562792", null, del); }
public IToken GenerateToken( string twitterConfirmationCode, string authorizationKey, string authorizationSecret, string consumerKey, string consumerSecret) { IOAuthCredentials credentials = new OAuthCredentials(authorizationKey, authorizationSecret, consumerKey, consumerSecret); IOAuthToken token = new OAuthToken(credentials); List <IOAuthQueryParameter> headers = token.GenerateParameters().ToList(); headers.Add(new OAuthQueryParameter("oauth_verifier", twitterConfirmationCode, true, true, false)); string response = ""; WebExceptionHandlingDelegate wex = delegate(WebException exception) { if (ExceptionUtils.GetWebExceptionStatusNumber(exception) == 401) { response = null; } }; response = token.ExecuteQueryWithSpecificParameters(Resources.OAuthRequestAccessToken, HttpMethod.POST, wex, headers); if (response == null) { return(null); } Match responseInformation = Regex.Match(response, Resources.OAuthTokenAccessRegex); IToken result = null; if (responseInformation.Groups["oauth_token"] != null && responseInformation.Groups["oauth_token_secret"] != null) { result = new Token(responseInformation.Groups["oauth_token"].Value, responseInformation.Groups["oauth_token_secret"].Value, consumerKey, consumerSecret); } return(result); }
/// <summary> /// Provide simplified ways to query a list of Messages /// </summary> /// <param name="token">Token to be used</param> /// <param name="queryUrl">URL from which we expect results</param> /// <param name="objectCreatedDelegate">Delegate to happen after a Message being created</param> /// <param name="wex">WebException to manage errors</param> /// <returns>Collection of messages retrieved from the query</returns> public static List <IMessage> GetMessages(IToken token, string queryUrl, ObjectCreatedDelegate <IMessage> objectCreatedDelegate = null, WebExceptionHandlingDelegate wex = null) { ObjectCreatorDelegate <IMessage> userCreator = delegate(Dictionary <string, object> data) { return(new Message(data)); }; return(GetListOfTwitterObject(token, queryUrl, userCreator, objectCreatedDelegate, wex)); }
/// <summary> /// Provide simplified ways to query a list of Tweets /// </summary> /// <param name="token">Token to be used</param> /// <param name="queryUrl">URL from which we expect results</param> /// <param name="objectCreatedDelegate">Delegate to happen after a Tweet being created</param> /// <param name="wex">WebException to manage errors</param> /// <returns>Collection of tweets retrieved from the query</returns> public static List <ITweet> GetTweets(IToken token, string queryUrl, ObjectCreatedDelegate <ITweet> objectCreatedDelegate = null, WebExceptionHandlingDelegate wex = null) { ObjectCreatorDelegate <ITweet> tweetCreator = delegate(Dictionary <string, object> data) { return(new Tweet(data)); }; return(GetListOfTwitterObject(token, queryUrl, tweetCreator, objectCreatedDelegate, wex)); }
/// <summary> /// Update the exception handler attribute with the 3rd parameter /// Get the list of users matching the Twitter request url (contributors or contributees) /// </summary> /// <param name="token"> Current user token to access the Twitter API</param> /// <param name="url">Twitter requets URL</param> /// <param name="exceptionHandlerDelegate">Delegate method to handle Twitter request exceptions</param> /// <returns>Null if the token parameter is null or if the Twitter request fails. A list of users otherwise (contributors or contributees).</returns> private List <IUser> GetContributionObjects(IToken token, String url, WebExceptionHandlingDelegate exceptionHandlerDelegate = null) { token = GetQueryToken(token); if (token == null) { Console.WriteLine("User's token is required"); return(null); } return(ResultGenerator.GetUsers(token, url, null, exceptionHandlerDelegate)); }
public Dictionary <string, object> ExecuteCursorQuery( string url, ref long cursor, int max = Int32.MaxValue, DynamicResponseDelegate responseHandler = null, WebExceptionHandlingDelegate exceptionHandler = null) { long previousCursor = cursor; long nextCursor = -1; int nbOfObjectsProcessed = 0; while (previousCursor != nextCursor && nbOfObjectsProcessed < max) { try { string queryDelimiter = "&"; if (url.EndsWith(".json") || url.EndsWith(".xml") || url.EndsWith(".")) { queryDelimiter = "?"; } Dictionary <string, object> responseObject = ExecuteGETQuery(String.Format("{0}" + queryDelimiter + "cursor={1}", url, nextCursor), null, exceptionHandler); // Go to the next object if (responseObject != null) { previousCursor = Int64.Parse(responseObject["previous_cursor"].ToString()); nextCursor = Int64.Parse(responseObject["next_cursor"].ToString()); } if (responseHandler != null) { // Manual response management nbOfObjectsProcessed += responseHandler(responseObject, previousCursor, nextCursor); } } catch (WebException wex) { if (ExceptionHandler != null) { ExceptionHandler(wex); } else { throw; } } } return(null); }
/// <summary> /// Get the Home timeline of the current user /// </summary> /// <param name="count">Maximum number of Tweet received</param> /// <param name="get_user_info">User information sent with the Tweet</param> /// <param name="exclude_replies">When true the replies to tweet are not retrieved</param> /// <param name="token">Token to be used to perform the query</param> /// <param name="since_id">Minimum Id of tweet to receive</param> /// <param name="max_id">Maximum Id of twee to receive</param> /// <param name="wex">Exception handler</param> /// <returns>Tweets from the Home timeline</returns> public List <ITweet> GetHomeTimeline( int count = 20, bool get_user_info = true, bool exclude_replies = true, IToken token = null, int?since_id = null, int?max_id = null, WebExceptionHandlingDelegate wex = null) { IToken queryToken = token ?? _token; return(GetHomeTimeLine(queryToken, count, get_user_info, exclude_replies, since_id, max_id, wex)); }
public Dictionary <string, object> ExecuteCursorQuery( string url, long cursor = 0, DynamicResponseDelegate responseHandler = null, WebExceptionHandlingDelegate exceptionHandler = null) { long previousCursor = cursor; long nextCursor = -1; while (previousCursor != nextCursor) { try { string queryDelimiter = "&"; if (url.EndsWith(".json") || url.EndsWith(".xml") || url.EndsWith(".")) { queryDelimiter = "?"; } dynamic responseObject = ExecuteGETQuery(String.Format("{0}" + queryDelimiter + "cursor={1}", url, nextCursor), null, exceptionHandler); // Go to the next object if (responseObject != null) { previousCursor = (long)responseObject["previous_cursor"]; nextCursor = (long)responseObject["next_cursor"]; } if (responseHandler != null) { // Manual response management responseHandler(responseObject, previousCursor, nextCursor); } } catch (WebException wex) { if (ExceptionHandler != null) { ExceptionHandler(wex); } else { throw; } } } return(null); }
// Execute a query that should return a single object private Dictionary <string, object> ExecuteQueryWithSingleResponse( string url, HttpMethod httpMethod, ObjectResponseDelegate objectDeletage, WebExceptionHandlingDelegate exceptionHandler) { Dictionary <string, object>[] results = ExecuteQuery(url, httpMethod, objectDeletage, exceptionHandler); if (results != null && results.Count() == 1) { return(results[0]); } return(null); }
/// <summary> /// Get the list of contributors to the account of the current user /// Update the matching attribute of the current user if the parameter is true /// Return the list of contributors /// </summary> /// <param name="createContributorList">False by default. Indicates if the _contributors attribute needs to be updated with the result</param> /// <returns>The list of contributors to the account of the current user</returns> public List <IUser> GetContributors(bool createContributorList = false) { // Specific error handler // Manage the error 400 thrown when contributors are not enabled by the current user WebExceptionHandlingDelegate del = delegate(WebException wex) { int?wexStatusNumber = ExceptionUtils.GetWebExceptionStatusNumber(wex); if (wexStatusNumber != null) { switch (wexStatusNumber) { case 400: // Don't need to do anything, the method will return null Console.WriteLine("Contributors are not enabled for this user"); break; default: // Other errors are not managed throw wex; } } else { throw wex; } }; List <IUser> result = null; // Contributors can be researched according to the user's id or screen_name if (this.Id != null) { result = GetContributionObjects(_token, String.Format(Resources.User_GetContributorsFromId, this.Id), del); } else if (this.ScreenName != null) { result = GetContributionObjects(_token, String.Format(Resources.User_GetContributorsFromScreenName, this.ScreenName), del); } // Update the attribute _contributors if required if (createContributorList) { _contributors = result; } return(result); }
protected bool Publish(IToken token, string query) { token = GetQueryToken(token); // If id exists it means that the tweet already exist on twitter // We cannot republish this tweet if (_id != null || _isTweetPublished || _isTweetDestroyed || String.IsNullOrEmpty(_text) || token == null) { return(false); } bool result = true; WebExceptionHandlingDelegate wexHandler = delegate(WebException wex) { int indexOfStatus = wex.Response.Headers.AllKeys.ToList().IndexOf("status"); if (indexOfStatus >= 0) { string statusValue = wex.Response.Headers.Get(indexOfStatus); switch (statusValue) { case "403 Forbidden": // You are trying to post the same Tweet another time! result = false; break; default: throw wex; } } else { throw wex; } }; ObjectResponseDelegate objectDelegate = Populate; token.ExecutePOSTQuery(query, objectDelegate, wexHandler); return(result); }
/// <summary> /// Get the list of contributors to the account of the current user /// Update the matching attribute of the current user if the parameter is true /// Return the list of contributors /// </summary> /// <param name="createContributorList">False by default. Indicates if the _contributors attribute needs to be updated with the result</param> /// <returns>The list of contributors to the account of the current user</returns> public List <IUser> GetContributors(bool createContributorList = false) { // Specific error handler // Manage the error 400 thrown when contributors are not enabled by the current user WebExceptionHandlingDelegate del = delegate(WebException wex) { int?wexStatusNumber = ExceptionUtils.GetWebExceptionStatusNumber(wex); if (wexStatusNumber != null) { switch (wexStatusNumber) { case 400: // Don't need to do anything, the method will return null Console.WriteLine("Contributors are not enabled for this user"); break; default: // Other errors are not managed throw wex; } } else { throw wex; } }; string query = Resources.User_GetContributors; if (!AddUserInformationInQuery(ref query)) { return(null); } List <IUser> result = GetContributionObjects(_token, query, del); if (createContributorList) { _contributors = result; } return(result); }
/// <summary> /// Populate the information of Tweet for which we set the ID /// </summary> /// <param name="token">Token to perform the query</param> /// <param name="cleanString">Clean the string so that it is readalble</param> public void PopulateTweet(IToken token, bool cleanString = true) { token = GetQueryToken(token); if (token != null) { string query; if (_id != null) { query = String.Format(Resources.Tweet_GetFromIdWithEntities, Id); } else { throw new Exception("Id needs to be set to retrieve it from Twitter."); } // If 404 error throw Exception that Tweet has not been created WebExceptionHandlingDelegate wex = delegate(WebException exception) { int indexOfStatus = exception.Response.Headers.AllKeys.ToList().IndexOf("status"); if (indexOfStatus != -1) { string statusValue = exception.Response.Headers.Get(indexOfStatus); // The tweet with the specific Id does not exist if (statusValue == "404 Not Found") { // Throwing an exception will stop the creation of the Tweet throw new Exception(String.Format("Tweet[{0}] does not exist!", Id)); } } }; Dictionary <String, object> dynamicTweet = token.ExecuteGETQuery(query, null, wex); Populate(dynamicTweet, cleanString); _token = token; } }
public List <IMention> GetLatestMentionsTimeline(int count = 20) { string query = String.Format(Resources.TokenUser_GetLatestMentionTimeline, count); WebExceptionHandlingDelegate wexDelegate = delegate(WebException wex) { int?wexStatusNumber = ExceptionUtils.GetWebExceptionStatusNumber(wex); switch (wexStatusNumber) { case 400: throw new WebException("Wrong token for user id = " + this.Id, wex); default: throw wex; } }; LatestMentionsTimeline = ResultGenerator.GetMentions(_token, query, null, wexDelegate); return(LatestMentionsTimeline); }
/// <summary> /// Method allowing to query and url /// </summary> /// <param name="method_url">Url from Twitter Api to query</param> /// <returns> /// Return a dynamic object containing the json information /// representing the value from a json response /// </returns> public dynamic ExecuteQuery(string method_url, WebExceptionHandlingDelegate exceptionHandlerDelegate = null) { dynamic result = null; try { HttpWebRequest web_request = GenerateRequest(new Uri(method_url)); WebResponse response = web_request.GetResponse(); StreamReader responseReader = new StreamReader(web_request.GetResponse().GetResponseStream()); if (response.Headers["X-RateLimit-Remaining"] != null) { XRateLimitRemaining = Int32.Parse(response.Headers["X-RateLimit-Remaining"]); } string jsonText = responseReader.ReadLine(); result = jss.Deserialize <dynamic>(jsonText); response.Close(); web_request.Abort(); } catch (WebException wex) { if (exceptionHandlerDelegate != null) { exceptionHandlerDelegate(wex); } else if (ExceptionHandler != null) { ExceptionHandler(wex); } else { throw wex; } } return(result); }
/// <summary> /// Method allowing to query and url /// </summary> /// <param name="method_url">Url from Twitter Api to query</param> /// <returns> /// Return a dynamic object containing the json information /// representing the value from a json response /// </returns> public dynamic ExecuteQuery(string method_url, WebExceptionHandlingDelegate exceptionHandlerDelegate = null) { dynamic result = null; try { HttpWebRequest web_request = GenerateRequest(new Uri(method_url)); WebResponse response = web_request.GetResponse(); StreamReader responseReader = new StreamReader(web_request.GetResponse().GetResponseStream()); if (response.Headers["X-RateLimit-Remaining"] != null) XRateLimitRemaining = Int32.Parse(response.Headers["X-RateLimit-Remaining"]); string jsonText = responseReader.ReadLine(); result = jss.Deserialize<dynamic>(jsonText); response.Close(); web_request.Abort(); } catch (WebException wex) { if (exceptionHandlerDelegate != null) exceptionHandlerDelegate(wex); else if (ExceptionHandler != null) ExceptionHandler(wex); else throw wex; } return result; }
public dynamic ExecuteCursorQuery(string method_url, long cursor = 0, DynamicResponseDelegate cursor_delegate = null, WebExceptionHandlingDelegate exceptionHandlerDelegate = null) { long previous_cursor = cursor; long next_cursor = -1; while (previous_cursor != next_cursor) { dynamic responseObject = null; try { responseObject = this.ExecuteQuery(String.Format("{0}&cursor={1}", method_url, next_cursor)); if (responseObject != null) { previous_cursor = (long)responseObject["previous_cursor"]; next_cursor = (long)responseObject["next_cursor"]; } if (cursor_delegate != null) cursor_delegate(responseObject, previous_cursor, next_cursor); } catch (WebException wex) { if (exceptionHandlerDelegate != null) exceptionHandlerDelegate(wex); else if (ExceptionHandler != null) ExceptionHandler(wex); else throw wex; } } return null; }