/// <summary>
/// Lets logged-in user un-follow another user.
/// </summary>
/// <param name="userID">ID of user to unfollow</param>
/// <returns>followed friend user info</returns>
public async Task <User?> DestroyFriendshipAsync(ulong userID, CancellationToken cancelToken = default(CancellationToken))
{
if (userID == 0)
{
throw new ArgumentException("userID is a required parameter.", "userID");
}
string destroyUrl = BaseUrl + "friendships/destroy.json";
var reqProc = new FriendshipRequestProcessor <User>();
RawResult =
await TwitterExecutor.PostFormUrlEncodedToTwitterAsync <User>(
HttpMethod.Post.ToString(),
destroyUrl,
new Dictionary <string, string?>
{
{ "user_id", userID.ToString() }
},
cancelToken)
.ConfigureAwait(false);
return(reqProc.ProcessActionResult(RawResult, FriendshipAction.Destroy));
}
/// <summary>
/// Adds a saved search to your twitter account
/// </summary>
/// <param name="query">Search query to add</param>
/// <returns>SavedSearch object</returns>
public async Task <SavedSearch?> CreateSavedSearchAsync(string query, CancellationToken cancelToken = default(CancellationToken))
{
if (string.IsNullOrWhiteSpace(query))
{
throw new ArgumentException("query is required.", "query");
}
var savedSearchUrl = BaseUrl + "saved_searches/create.json";
var reqProc = new SavedSearchRequestProcessor <SavedSearch>();
RawResult =
await TwitterExecutor.PostFormUrlEncodedToTwitterAsync <SavedSearch>(
HttpMethod.Post.ToString(),
savedSearchUrl,
new Dictionary <string, string?>
{
{ "query", query }
},
cancelToken)
.ConfigureAwait(false);
return(reqProc.ProcessActionResult(RawResult, SavedSearchAction.Create));
}
/// <summary>
/// Lets logged-in user un-follow another user.
/// </summary>
/// <param name="screenName">Screen name of user to unfollow</param>
/// <returns>followed friend user info</returns>
public async Task <User?> DestroyFriendshipAsync(string screenName, CancellationToken cancelToken = default(CancellationToken))
{
if (string.IsNullOrWhiteSpace(screenName))
{
throw new ArgumentException("screenName is a required parameter.", "screenName");
}
string destroyUrl = BaseUrl + "friendships/destroy.json";
var reqProc = new FriendshipRequestProcessor <User>();
RawResult =
await TwitterExecutor.PostFormUrlEncodedToTwitterAsync <User>(
HttpMethod.Post.ToString(),
destroyUrl,
new Dictionary <string, string?>
{
{ "screen_name", screenName }
},
cancelToken)
.ConfigureAwait(false);
return(reqProc.ProcessActionResult(RawResult, FriendshipAction.Destroy));
}
/// <summary>
/// Sends an image to Twitter to be placed as the user's profile banner.
/// </summary>
/// <param name="banner">byte[] containing image data.</param>
/// <param name="width">Pixel width to clip image.</param>
/// <param name="height">Pixel height to clip image.</param>
/// <param name="offsetLeft">Pixels to offset start of image from the left.</param>
/// <param name="offsetTop">Pixels to offset start of image from the top.</param>
/// <returns>
/// Account of authenticated user who's profile banner will be updated.
/// Url of new banner will appear in ProfileBannerUrl property.
/// </returns>
public async Task <User> UpdateProfileBannerAsync(byte[] banner, int width, int height, int offsetLeft, int offsetTop, CancellationToken cancelToken = default(CancellationToken))
{
var accountUrl = BaseUrl + "account/update_profile_banner.json";
if (banner == null || banner.Length == 0)
{
throw new ArgumentException("banner is required.", "banner");
}
var parameters = new Dictionary <string, string>
{
{ "width", width.ToString() },
{ "height", height.ToString() },
{ "offset_left", offsetLeft.ToString() },
{ "offset_top", offsetTop.ToString() },
{ "banner", Convert.ToBase64String(banner) }
};
var reqProc = new UserRequestProcessor <User>();
RawResult = await TwitterExecutor.PostFormUrlEncodedToTwitterAsync <User>(HttpMethod.Post.ToString(), accountUrl, parameters, cancelToken).ConfigureAwait(false);
return(reqProc.ProcessActionResult(RawResult, UserAction.SingleUser));
}
/// <summary>
/// Deletes a direct message.
/// </summary>
/// <param name="id">id of direct message</param>
/// <param name="includeEntites">Set to false to prevent entities from being included (default: true).</param>
/// <returns>direct message element</returns>
public async Task <DirectMessage> DestroyDirectMessageAsync(ulong id, bool includeEntites, CancellationToken cancelToken = default(CancellationToken))
{
if (id == 0)
{
throw new ArgumentNullException("id", "id is required.");
}
var destroyUrl = BaseUrl + "direct_messages/destroy.json";
var reqProc = new DirectMessageRequestProcessor <DirectMessage>();
RawResult =
await TwitterExecutor.PostToTwitterAsync <DirectMessage>(
destroyUrl,
new Dictionary <string, string>
{
{ "id", id.ToString() },
{ "include_entities", includeEntites.ToString().ToLower() }
},
cancelToken)
.ConfigureAwait(false);
return(reqProc.ProcessActionResult(RawResult, DirectMessageType.Show));
}
/// <summary>
/// Adds a saved search to your twitter account
/// </summary>
/// <param name="id">ID of saved search</param>
/// <param name="callback">Async Callback used in Silverlight queries</param>
/// <returns>SavedSearch object</returns>
public async Task <SavedSearch> DestroySavedSearchAsync(ulong id, CancellationToken cancelToken = default(CancellationToken))
{
if (id == 0)
{
throw new ArgumentException("Invalid Saved Search ID: " + id, "id");
}
var savedSearchUrl = BaseUrl + "saved_searches/destroy/" + id + ".json";
var reqProc = new SavedSearchRequestProcessor <SavedSearch>();
RawResult =
await TwitterExecutor.PostToTwitterAsync <SavedSearch>(
savedSearchUrl,
new Dictionary <string, string>(),
cancelToken)
.ConfigureAwait(false);
SavedSearch result = reqProc.ProcessActionResult(RawResult, SavedSearchAction.Destroy);
result.ID = id;
return(result);
}
/// <summary>
/// Deletes a favorite from the logged-in user's profile.
/// </summary>
/// <param name="id">id of status to add to favorites</param>
/// <param name="includeEntities">Response doesn't include entities when false. (default: true)</param>
/// <returns>status of favorite</returns>
public async Task <Status> DestroyFavoriteAsync(ulong id, bool includeEntities, CancellationToken cancelToken = default(CancellationToken))
{
if (id == 0)
{
throw new ArgumentException("id is a required parameter.", "id");
}
var favoritesUrl = BaseUrl + "favorites/destroy.json";
var reqProc = new StatusRequestProcessor <Status>();
RawResult =
await TwitterExecutor.PostToTwitterAsync <Status>(
favoritesUrl,
new Dictionary <string, string>
{
{ "id", id.ToString() },
{ "include_entities", includeEntities.ToString() }
},
cancelToken)
.ConfigureAwait(false);
return(reqProc.ProcessActionResult(RawResult, FavoritesAction.SingleStatus));
}
/// <summary>
/// Uploads a media (e.g. media) to be attached to a subsequent tweet.
/// </summary>
/// <param name="media">Media to upload</param>
/// <param name="mediaType">Type of media. e.g. image/jpg, image/png, or video/mp4.</param>
/// <param name="additionalOwners">User IDs of accounts that can used the returned media IDs</param>
/// <param name="mediaCategory">
/// Media category - possible values are tweet_image, tweet_gif, tweet_video, and amplify_video.
/// See this post on the Twitter forums: https://twittercommunity.com/t/media-category-values/64781/6
/// </param>
/// <param name="cancelToken">Allows you to cancel async operation</param>
/// <returns>Status containing new reply</returns>
public virtual async Task <Media> UploadMediaAsync(byte[] media, string mediaType, IEnumerable <ulong> additionalOwners, string mediaCategory, CancellationToken cancelToken = default(CancellationToken))
{
if (media == null || media.Length == 0)
{
throw new ArgumentNullException("image", "You must provide a byte[] of image data.");
}
string updateUrl = UploadUrl + "media/upload.json";
string name = "media";
string randomUnusedFileName = new Random().Next(100, 999).ToString();
var parameters = new Dictionary <string, string>();
if (additionalOwners != null && additionalOwners.Any())
{
parameters.Add("additional_owners", string.Join(",", additionalOwners));
}
var reqProc = new StatusRequestProcessor <Status>();
RawResult =
await TwitterExecutor.PostMediaAsync(
updateUrl,
new Dictionary <string, string>(),
media,
name,
randomUnusedFileName,
mediaType,
mediaCategory,
cancelToken)
.ConfigureAwait(false);
Status status = reqProc.ProcessActionResult(RawResult, StatusAction.MediaUpload);
return(status.Media);
}
/// <summary>
/// Sends an image file to Twitter to replace background image.
/// </summary>
/// <param name="image">full path to file, including file name</param>
/// <param name="mediaID">ID of media to use (posted via UploadMediaAsync)</param>
/// <param name="fileName">name to pass to Twitter for the file</param>
/// <param name="imageType">type of image: must be one of jpg, gif, or png</param>
/// <param name="tile">Tile image across background.</param>
/// <param name="includeEntities">Set to false to not include entities. (default: true)</param>
/// <param name="skipStatus">Don't include status with response.</param>
/// <returns>User with new image info</returns>
public async Task <User> UpdateAccountBackgroundImageAsync(byte[] image, ulong mediaID, string fileName, string imageType, bool tile, bool includeEntities, bool skipStatus, CancellationToken cancelToken = default(CancellationToken))
{
var accountUrl = BaseUrl + "account/update_profile_background_image.json";
if (mediaID == NoMediaID && image == NoImage)
{
throw new ArgumentException("Either image or mediaID must be provided, but you haven't specified one.", nameof(image) + "Or" + nameof(mediaID));
}
if (mediaID == NoMediaID && image.Length == 0)
{
throw new ArgumentException("Invalid image", nameof(image));
}
if (image != NoImage && mediaID != NoMediaID)
{
throw new ArgumentException("Either image or mediaID must be provided, but not both", nameof(image) + "Or" + nameof(mediaID));
}
if (string.IsNullOrWhiteSpace(fileName))
{
throw new ArgumentException("fileName is required.", nameof(fileName));
}
if (string.IsNullOrWhiteSpace(imageType))
{
throw new ArgumentException("imageType is required.", nameof(imageType));
}
var parameters = new Dictionary <string, string>
{
{ "include_entities", includeEntities.ToString().ToLower() },
{ "skip_status", skipStatus.ToString().ToLower() }
};
if (tile)
{
parameters.Add("tile", true.ToString().ToLower());
}
if (mediaID != NoMediaID)
{
parameters.Add("media_id", mediaID.ToString());
}
var reqProc = new UserRequestProcessor <User>();
string name = "image";
string imageMimeType = "image/" + imageType;
string mediaCategory = "tweet_image";
if (image != NoImage)
{
RawResult = await TwitterExecutor.PostMediaAsync(accountUrl, parameters, image, name, fileName, imageMimeType, mediaCategory, shared : false, cancelToken : cancelToken).ConfigureAwait(false);
}
else
{
RawResult = await TwitterExecutor.PostFormUrlEncodedToTwitterAsync <User>(HttpMethod.Post.ToString(), accountUrl, parameters, cancelToken).ConfigureAwait(false);
}
return(reqProc.ProcessActionResult(RawResult, UserAction.SingleUser));
}
