/// <summary>
/// Update Twitter colors
/// </summary>
/// <remarks>
/// The # character prefix is optional. At least one color argument must be provided.
/// </remarks>
/// <param name="background">background color</param>
/// <param name="text">text color</param>
/// <param name="link">link color</param>
/// <param name="sidebarFill">sidebar color</param>
/// <param name="sidebarBorder">sidebar border color</param>
/// <returns>User info with new colors</returns>
public User UpdateAccountColors(string background, string text, string link, string sidebarFill, string sidebarBorder)
{
var accountUrl = BaseUrl + "account/update_profile_colors.xml";
if (string.IsNullOrEmpty(background) &&
string.IsNullOrEmpty(text) &&
string.IsNullOrEmpty(link) &&
string.IsNullOrEmpty(sidebarFill) &&
string.IsNullOrEmpty(sidebarBorder))
{
throw new ArgumentException("At least one of the colors (background, text, link, sidebarFill, or sidebarBorder) must be provided as arguments, but none are specified.");
}
var results =
TwitterExecute.ExecuteTwitter(
accountUrl,
new Dictionary <string, string>
{
{ "profile_background_color", background.TrimStart('#') },
{ "profile_text_color", text.TrimStart('#') },
{ "profile_link_color", link.TrimStart('#') },
{ "profile_sidebar_fill_color", sidebarFill.TrimStart('#') },
{ "profile_sidebar_border_color", sidebarBorder.TrimStart('#') }
},
new UserRequestProcessor());
return((results as IList <User>).FirstOrDefault());
}
/// <summary>
/// sends a new direct message to specified userr
/// </summary>
/// <param name="userID">id of user to send to</param>
/// <param name="id">text to send</param>
/// <returns>direct message element</returns>
public DirectMessage NewDirectMessage(string userID, string text)
{
if (string.IsNullOrEmpty(userID))
{
throw new ArgumentException("userID is a required parameter.", "userID");
}
if (string.IsNullOrEmpty(text))
{
throw new ArgumentException("text is a required parameter.", "text");
}
if (text.Length > 140)
{
throw new ArgumentException("text must be no longer than 140 characters.", "text");
}
var newUrl = BaseUrl + "direct_messages/new.xml";
var results =
TwitterExecute.ExecuteTwitter(
newUrl,
new Dictionary <string, string>
{
{ "user", userID },
{ "text", text }
},
new DirectMessageRequestProcessor());
return((results as IList <DirectMessage>).FirstOrDefault());
}
/// <summary>
/// lets logged-in user follow another user
/// </summary>
/// <param name="id">id of user to follow</param>
/// <returns>followed friend user info</returns>
public User CreateFriendship(string id, string userID, string screenName, bool follow)
{
if (string.IsNullOrEmpty(id) &&
string.IsNullOrEmpty(userID) &&
string.IsNullOrEmpty(screenName))
{
throw new ArgumentException("Either id, userID, or screenName is a required parameter.");
}
var destroyUrl = BaseUrl + "friendships/create/" + id + ".xml";
var createParams = new Dictionary <string, string>
{
{ "user_id", userID },
{ "screen_name", screenName }
};
// If follow exists in the parameter list, Twitter will
// always treat it as true, even if the value is false;
// Therefore, only add follow if it is true.
if (follow)
{
createParams.Add("follow", "true");
}
var results =
TwitterExecute.ExecuteTwitter(
destroyUrl,
createParams,
new UserRequestProcessor());
return((results as IList <User>).FirstOrDefault());
}
/// <summary>
/// sends an image file to Twitter to replace background image
/// </summary>
/// <param name="imageFilePath">full path to file, including file name</param>
/// <returns>User with new image info</returns>
public User UpdateAccountBackgroundImage(string imageFilePath, bool tile)
{
var accountUrl = BaseUrl + "account/update_profile_background_image.xml";
if (string.IsNullOrEmpty(imageFilePath))
{
throw new ArgumentException("imageFilePath is required.", "imageFilePath");
}
Dictionary <string, string> parameters = null;
// TODO: tile implementation doesn't seem to be working; numerous update background image problems reported in Twitter API; check again later - Joe
if (tile)
{
parameters =
new Dictionary <string, string>
{
{ "tile", "true" }
};
}
var results = TwitterExecute.PostTwitterFile(imageFilePath, parameters, accountUrl, new UserRequestProcessor());
return((results as IList <User>).FirstOrDefault());
}
/// <summary>
/// sends a status update
/// </summary>
/// <param name="status">(optional @UserName) and (required) status text</param>
/// <param name="inReplyToStatusID">id of status replying to - optional - pass null if not used</param>
/// <returns>IQueryable of sent status</returns>
public Status UpdateStatus(string status, string inReplyToStatusID)
{
if (string.IsNullOrEmpty(status))
{
throw new ArgumentException("status is a required parameter.");
}
if (status.Length > 140)
{
throw new ArgumentException("status length must be no more than 140 characters.", "status");
}
status = status.Substring(0, Math.Min(140, status.Length));
var updateUrl = BaseUrl + "statuses/update.xml";
var results =
TwitterExecute.ExecuteTwitter(
updateUrl,
new Dictionary <string, string>
{
{ "status", status },
{ "in_reply_to_status_id", inReplyToStatusID }
},
new StatusRequestProcessor());
return((results as IList <Status>).FirstOrDefault());
}
/// <summary>
/// sends a test message to twitter to check connectivity
/// </summary>
/// <returns>true</returns>
public bool HelpTest()
{
var helpUrl = BaseUrl + "help/test.xml";
var results =
TwitterExecute.ExecuteTwitter(
helpUrl,
new Dictionary <string, string>(),
new HelpRequestProcessor());
return((results as IList <bool>).FirstOrDefault());
}
/// <summary>
/// Update account profile info
/// </summary>
/// <param name="name">User Name</param>
/// <param name="email">Email Address</param>
/// <param name="url">Web Address</param>
/// <param name="location">Geographic Location</param>
/// <param name="description">Personal Description</param>
/// <returns>User with new info</returns>
public User UpdateAccountProfile(string name, string email, string url, string location, string description)
{
var accountUrl = BaseUrl + "account/update_profile.xml";
if (string.IsNullOrEmpty(name) &&
string.IsNullOrEmpty(email) &&
string.IsNullOrEmpty(url) &&
string.IsNullOrEmpty(location) &&
string.IsNullOrEmpty(description))
{
throw new ArgumentException("At least one of the colors (name, email, url, location, or description) must be provided as arguments, but none are specified.");
}
if (!string.IsNullOrEmpty(name) && name.Length > 20)
{
throw new ArgumentException("name must be no longer than 20 characters", "name");
}
if (!string.IsNullOrEmpty(email) && email.Length > 40)
{
throw new ArgumentException("email must be no longer than 40 characters", "email");
}
if (!string.IsNullOrEmpty(url) && url.Length > 100)
{
throw new ArgumentException("url must be no longer than 100 characters", "url");
}
if (!string.IsNullOrEmpty(location) && location.Length > 30)
{
throw new ArgumentException("location must be no longer than 30 characters", "location");
}
if (!string.IsNullOrEmpty(description) && description.Length > 160)
{
throw new ArgumentException("description must be no longer than 160 characters", "description");
}
var results =
TwitterExecute.ExecuteTwitter(
accountUrl,
new Dictionary <string, string>
{
{ "name", name },
{ "email", email },
{ "url", url },
{ "location", location },
{ "description", description }
},
new UserRequestProcessor());
return((results as IList <User>).FirstOrDefault());
}
/// <summary>
/// initialize TwitterContext with credentials and custom BaseUrl
/// </summary>
/// <param name="userName">name of user</param>
/// <param name="password">user's password</param>
/// <param name="baseUrl">base url of Twitter API</param>
/// <param name="searchUrl">base url of Twitter Search API</param>
public TwitterContext(string userName, string password, string baseUrl, string searchUrl)
{
TwitterExecute = new TwitterExecute();
TwitterExecute.OAuthTwitter = OAuthTwitter;
UserName = userName;
Password = password;
BaseUrl = string.IsNullOrEmpty(baseUrl) ? "http://twitter.com/" : baseUrl;
SearchUrl = string.IsNullOrEmpty(searchUrl) ? "http://search.twitter.com/" : searchUrl;
OAuthAccessTokenUrl = "http://twitter.com/oauth/access_token";
OAuthAuthorizeUrl = "http://twitter.com/oauth/authorize";
OAuthRequestTokenUrl = "http://twitter.com/oauth/request_token";
}
/// <summary>
/// sends an image file to Twitter to replace user image
/// </summary>
/// <remarks>
/// You can only run this method with a period of time between executions;
/// otherwise you get WebException errors from Twitter
/// </remarks>
/// <param name="imageFilePath">full path to file, including file name</param>
/// <returns>User with new image info</returns>
public User UpdateAccountImage(string imageFilePath)
{
var accountUrl = BaseUrl + "account/update_profile_image.xml";
if (string.IsNullOrEmpty(imageFilePath))
{
throw new ArgumentException("imageFilePath is required.", "imageFilePath");
}
var results = TwitterExecute.PostTwitterFile(imageFilePath, null, accountUrl, new UserRequestProcessor());
return((results as IList <User>).FirstOrDefault());
}
/// <summary>
/// Updates notification device for account
/// </summary>
/// <param name="device">type of device to use</param>
/// <returns>User info</returns>
public User UpdateAccountDeliveryDevice(DeviceType device)
{
var accountUrl = BaseUrl + "account/update_delivery_device.xml";
var results =
TwitterExecute.ExecuteTwitter(
accountUrl,
new Dictionary <string, string>
{
{ "device", device.ToString().ToLower() }
},
new UserRequestProcessor());
return((results as IList <User>).FirstOrDefault());
}
/// <summary>
/// deletes a direct message
/// </summary>
/// <param name="id">id of direct message</param>
/// <returns>direct message element</returns>
public DirectMessage DestroyDirectMessage(string id)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentException("id is a required parameter.", "id");
}
var destroyUrl = BaseUrl + "direct_messages/destroy/" + id + ".xml";
var results =
TwitterExecute.ExecuteTwitter(
destroyUrl,
new Dictionary <string, string>(),
new DirectMessageRequestProcessor());
return((results as IList <DirectMessage>).FirstOrDefault());
}
/// <summary>
/// Unblocks a user
/// </summary>
/// <param name="id">id of user to unblock</param>
/// <returns>User that was unblocked</returns>
public User DestroyBlock(string id)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentException("id is a required parameter.", "id");
}
var blocksUrl = BaseUrl + "blocks/destroy/" + id + ".xml";
var results =
TwitterExecute.ExecuteTwitter(
blocksUrl,
new Dictionary <string, string>(),
new UserRequestProcessor());
return((results as IList <User>).FirstOrDefault());
}
/// <summary>
/// Deletes a favorite from the logged-in user's profile
/// </summary>
/// <param name="id">id of status to add to favorites</param>
/// <returns>status of favorite</returns>
public Status DestroyFavorite(string id)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentException("id is a required parameter.", "id");
}
var favoritesUrl = BaseUrl + "favorites/destroy/" + id + ".xml";
var results =
TwitterExecute.ExecuteTwitter(
favoritesUrl,
new Dictionary <string, string>(),
new StatusRequestProcessor());
return((results as IList <Status>).FirstOrDefault());
}
/// <summary>
/// Ends the session for the currently logged in user
/// </summary>
/// <returns>true</returns>
public TwitterHashResponse EndAccountSession()
{
var accountUrl = BaseUrl + "account/end_session.xml";
var results =
TwitterExecute.ExecuteTwitter(
accountUrl,
new Dictionary <string, string>(),
new AccountRequestProcessor());
var acct = (results as IList <Account>).FirstOrDefault();
if (acct != null)
{
return(acct.EndSessionStatus);
}
else
{
throw new WebException("Unknown Twitter Response.");
}
}
/// <summary>
/// Disables notifications from specified user. (Notification Leave)
/// </summary>
/// <remarks>
/// A least one parameter is required.
/// </remarks>
/// <param name="id">ID of user to disable notifications on.</param>
/// <param name="userID">ID of user - disambiguates when ID is screen name.</param>
/// <param name="screenName">Screen Name of user - disambiguates when ID is screen name.</param>
/// <returns>Specified user info</returns>
public User DisableNotifications(string id, string userID, string screenName)
{
if (string.IsNullOrEmpty(id) &&
string.IsNullOrEmpty(userID) &&
string.IsNullOrEmpty(screenName))
{
throw new ArgumentException("Either id, userID, or screenName is a required parameter.");
}
var notificationsUrl = BaseUrl + "notifications/leave/" + id + ".xml";
var results =
TwitterExecute.ExecuteTwitter(
notificationsUrl,
new Dictionary <string, string>
{
{ "user_id", userID },
{ "screen_name", screenName }
},
new UserRequestProcessor());
return((results as IList <User>).FirstOrDefault());
}
/// <summary>
/// Called by QueryProvider to execute queries
/// </summary>
/// <param name="expression">ExpressionTree to parse</param>
/// <returns>list of objects with query results</returns>
internal object Execute(Expression expression, bool isEnumerable)
{
Dictionary <string, string> parameters = null;
// request processor is specific to request type (i.e. Status, User, etc.)
var reqProc = CreateRequestProcessor(expression, isEnumerable);
// we need the where expression because it contains the criteria for the request
var whereFinder = new FirstWhereClauseFinder();
var whereExpression = whereFinder.GetFirstWhere(expression);
if (whereExpression != null)
{
var lambdaExpression = (LambdaExpression)
((UnaryExpression)(whereExpression.Arguments[1])).Operand;
// translate variable references in expression into constants
lambdaExpression = (LambdaExpression)Evaluator.PartialEval(lambdaExpression);
parameters = reqProc.GetParameters(lambdaExpression);
}
// construct REST endpoint, based on input parameters
var url = reqProc.BuildURL(parameters);
// execute the query and return results
var queryableList = TwitterExecute.QueryTwitter(url, reqProc);
if (isEnumerable)
{
return(queryableList);
}
else
{
return(queryableList[0]);
}
}
public TwitterExecuteErrorHandlingTests()
{
var authMock = new Mock<ITwitterAuthorizer>();
twitExe = new TwitterExecute(authMock.Object);
}
public void TwitterContext_Three_Param_Constructor_Sets_Defaults()
{
ITwitterExecute execute = new TwitterExecute(new PinAuthorizer());
const string BaseUrl = "http://api.twitter.com/1/";
const string SearchUrl = "http://search.twitter.com/";
var ctx = new TwitterContext(execute, BaseUrl, SearchUrl);
Assert.Equal(BaseUrl, ctx.BaseUrl);
Assert.Equal(SearchUrl, ctx.SearchUrl);
}
