/// <summary>
/// Adds a favorite to 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>
/// <param name="callback">Async Callback used in Silverlight queries</param>
/// <returns>status of favorite</returns>
public static Status CreateFavorite(this TwitterContext ctx, string id, bool includeEntities, Action<TwitterAsyncResponse<Status>> callback)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentException("id is a required parameter.", "id");
}
var favoritesUrl = ctx.BaseUrl + "favorites/create.json";
var reqProc = new StatusRequestProcessor<Status>();
ITwitterExecute twitExe = ctx.TwitterExecutor;
twitExe.AsyncCallback = callback;
var resultsJson =
twitExe.PostToTwitter(
favoritesUrl,
new Dictionary<string, string>
{
{"id", id},
{"include_entities", includeEntities.ToString()}
},
response => reqProc.ProcessActionResult(response, FavoritesAction.SingleStatus));
Status result = reqProc.ProcessActionResult(resultsJson, FavoritesAction.SingleStatus);
return result;
}
/// <summary>
/// Uploads a media (e.g. media) to be attached to a subsequent tweet.
/// </summary>
/// <param name="media">Media to upload</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, 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 imageType = "application/octet-stream";
string name = "media";
string randomUnusedFileName = new Random().Next(100, 999).ToString();
var reqProc = new StatusRequestProcessor<Status>();
RawResult =
await TwitterExecutor.PostMediaAsync(
updateUrl,
new Dictionary<string, string>(),
media,
name,
randomUnusedFileName,
imageType,
cancelToken)
.ConfigureAwait(false);
Status status = reqProc.ProcessActionResult(RawResult, StatusAction.MediaUpload);
return status.Media;
}
public void BuildUrl_Returns_Url_For_OEmbed()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/statuses/oembed.json?id=1&url=abc&maxwidth=300&hide_media=true&hide_thread=true&omit_script=true&align=left&related=JoeMayo%2CTwitterAPI&lang=en";
var reqProc = new StatusRequestProcessor <Status>
{
Type = StatusType.Oembed,
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)StatusType.Oembed).ToString() },
{ "ID", "1" },
{ "OEmbedUrl", "abc" },
{ "OEmbedMaxWidth", "300" },
{ "OEmbedHideMedia", true.ToString() },
{ "OEmbedHideThread", true.ToString() },
{ "OEmbedOmitScript", true.ToString() },
{ "OEmbedAlign", ((int)EmbeddedStatusAlignment.Left).ToString() },
{ "OEmbedRelated", "JoeMayo, TwitterAPI" },
{ "OEmbedLanguage", "en" }
};
Request req = reqProc.BuildUrl(parameters);
Assert.Equal(ExpectedUrl, req.FullUrl);
}
public void ProcessResults_Handles_Multiple_Users()
{
var statProc = new StatusRequestProcessor <Status> {
Type = StatusType.Retweeters, BaseUrl = "https://api.twitter.com/1.1/"
};
var statuses = statProc.ProcessResults(MultipleUsersResponse);
Assert.NotNull(statuses);
Assert.Single(statuses);
var status = statuses.Single();
Assert.NotNull(status);
var users = status.Users;
Assert.NotNull(users);
Assert.Equal(5, users.Count);
ulong user = users.First();
Assert.Equal(34649740ul, user);
var cursor = status.CursorMovement;
Assert.NotNull(cursor);
Assert.Equal("123", cursor.Next);
Assert.Equal("456", cursor.Previous);
}
public void ProcessResults_Populates_EmbeddedStatus_Parameters()
{
var statProc = new StatusRequestProcessor <Status>()
{
BaseUrl = "https://api.twitter.com/1.1/",
Type = StatusType.Oembed,
ID = "123",
OEmbedUrl = "http://myurl.com",
OEmbedMaxWidth = 300,
OEmbedHideMedia = true,
OEmbedHideThread = true,
OEmbedOmitScript = true,
OEmbedAlign = EmbeddedStatusAlignment.Left,
OEmbedRelated = "JoeMayo,TwitterAPI",
OEmbedLanguage = "en"
};
var statuses = statProc.ProcessResults(OEmbedResponse);
Assert.NotNull(statuses);
Assert.Single(statuses);
var status = statuses.Single();
Assert.NotNull(status);
Assert.Equal(StatusType.Oembed, status.Type);
Assert.Equal("123", status.ID);
Assert.Equal("http://myurl.com", status.OEmbedUrl);
Assert.Equal(300, status.OEmbedMaxWidth);
Assert.True(status.OEmbedHideMedia);
Assert.True(status.OEmbedHideThread);
Assert.True(status.OEmbedOmitScript);
Assert.Equal(EmbeddedStatusAlignment.Left, status.OEmbedAlign);
Assert.Equal("JoeMayo,TwitterAPI", status.OEmbedRelated);
Assert.Equal("en", status.OEmbedLanguage);
}
/// <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="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, 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,
cancelToken)
.ConfigureAwait(false);
Status status = reqProc.ProcessActionResult(RawResult, StatusAction.MediaUpload);
return status.Media;
}
public void StatusRequestProcessor_Works_With_Json_Format_Data()
{
var statProc = new StatusRequestProcessor <Status> {
BaseUrl = "https://api.twitter.com/1.1/"
};
Assert.IsAssignableFrom <IRequestProcessorWantsJson>(statProc);
}
public void StatusRequestProcessor_Works_With_Json_Format_Data()
{
var statProc = new StatusRequestProcessor <Status> {
BaseUrl = "https://api.twitter.com/1.1/"
};
Assert.IsInstanceOfType(statProc, typeof(IRequestProcessorWantsJson));
}
public void ProcessResults_Handles_A_Single_Status()
{
var statProc = new StatusRequestProcessor <Status> {
Type = StatusType.Show, BaseUrl = "https://api.twitter.com/1.1/"
};
var statuses = statProc.ProcessResults(SingleStatusResponse);
Assert.IsNotNull(statuses);
Assert.AreEqual(1, statuses.Count);
var status = statuses.Single();
Assert.IsNotNull(status);
Assert.IsNotNull(status.Annotation);
Assert.IsNotNull(status.Annotation.Attributes);
Assert.IsFalse(status.Annotation.Attributes.Any());
Assert.IsNotNull(status.Annotation.Elements);
Assert.IsFalse(status.Annotation.Elements.Any());
Assert.AreEqual(new DateTime(2012, 3, 28, 2, 51, 45), status.CreatedAt);
var contributors = status.Contributors;
Assert.IsNotNull(contributors);
Assert.IsFalse(contributors.Any());
var coords = status.Coordinates;
Assert.IsNotNull(coords);
Assert.AreEqual(-122.40060, coords.Longitude);
Assert.AreEqual(37.78215, coords.Latitude);
Assert.IsNotNull(status.Entities);
Assert.IsNotNull(status.Entities.HashTagEntities);
Assert.IsFalse(status.Entities.HashTagEntities.Any());
Assert.IsFalse(status.Favorited);
Assert.IsNull(status.InReplyToScreenName);
Assert.AreEqual(0ul, status.InReplyToStatusID);
Assert.AreEqual(0ul, status.InReplyToUserID);
Assert.IsNotNull(status.Place);
Assert.IsNull(status.Place.Name);
Assert.IsFalse(status.PossiblySensitive);
Assert.AreEqual(393, status.RetweetCount);
Assert.IsFalse(status.Retweeted);
var retweetedStatus = status.RetweetedStatus;
Assert.IsNotNull(retweetedStatus);
Assert.IsNotNull(retweetedStatus.Text);
Assert.IsTrue(retweetedStatus.Text.StartsWith("I just blogged about"));
Assert.AreEqual("web", status.Source);
Assert.IsTrue(status.Text.StartsWith("RT @scottgu: I just blogged about"));
Assert.AreEqual(184835136037191681ul, status.StatusID);
Assert.IsNotNull(status.Text);
Assert.IsFalse(status.Truncated);
Assert.IsNotNull(status.User);
Assert.AreEqual("Joe Mayo", status.User.Name);
Assert.IsNotNull(status.Users);
Assert.IsFalse(status.Users.Any());
Assert.IsNotNull(status.WithheldInCountries);
Assert.IsFalse(status.WithheldInCountries.Any());
}
public void BuildUrl_Throws_On_Null_Parameter()
{
var target = new StatusRequestProcessor <Status> {
BaseUrl = "https://api.twitter.com/1.1/"
};
var ex = Assert.Throws <ArgumentException>(() => target.BuildUrl(null));
Assert.Equal <string>("Type", ex.ParamName);
}
public void ProcessResults_Returns_Empty_Collection_When_Empty_Results()
{
var statProc = new StatusRequestProcessor <Status>()
{
BaseUrl = "https://api.twitter.com/1.1/"
};
var stats = statProc.ProcessResults(string.Empty);
Assert.Equal(0, stats.Count);
}
public void BuildUrl_Throws_On_Missing_Type()
{
var statusReqProc = new StatusRequestProcessor <Status> {
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string> {
};
var ex = Assert.Throws <ArgumentException>(() => statusReqProc.BuildUrl(parameters));
Assert.Equal <string>("Type", ex.ParamName);
}
public void ProcessResultsSingleResultTest()
{
var statProc = new StatusRequestProcessor()
{
BaseUrl = "http://twitter.com/"
};
XElement twitterResponse = XElement.Load(new StringReader(m_testQueryResponse));
var actual = statProc.ProcessResults(twitterResponse.Descendants("status").First());
var actualQuery = actual as IList <Status>;
Assert.IsNotNull(actualQuery);
Assert.AreEqual(actualQuery.Count(), 1);
}
public void BuildURLPublicTest()
{
var statProc = new StatusRequestProcessor()
{
BaseUrl = "http://twitter.com/"
};
Dictionary <string, string> parameters = null;
string expected = "http://twitter.com/statuses/public_timeline.xml";
string actual;
actual = statProc.BuildURL(parameters);
Assert.AreEqual(expected, actual);
}
public void ProcessResults_Populates_Input_Parameters()
{
var statProc = new StatusRequestProcessor <Status>()
{
BaseUrl = "https://api.twitter.com/1.1/",
Type = StatusType.Show,
ID = 123,
UserID = 123,
ScreenName = "abc",
SinceID = 1,
MaxID = 2,
Count = 3,
Cursor = 123,
IncludeRetweets = true,
ExcludeReplies = true,
IncludeEntities = true,
IncludeUserEntities = true,
TrimUser = true,
IncludeContributorDetails = true,
IncludeMyRetweet = true,
TweetIDs = "1,2,3",
Map = true
};
var statuses = statProc.ProcessResults(SingleStatusResponse);
Assert.IsNotNull(statuses);
Assert.AreEqual(1, statuses.Count);
var status = statuses.Single();
Assert.IsNotNull(status);
Assert.AreEqual(StatusType.Show, status.Type);
Assert.AreEqual(123ul, status.ID);
Assert.AreEqual(123ul, status.UserID);
Assert.AreEqual("abc", status.ScreenName);
Assert.AreEqual(1ul, status.SinceID);
Assert.AreEqual(2ul, status.MaxID);
Assert.AreEqual(3, status.Count);
Assert.AreEqual(123L, status.Cursor);
Assert.IsTrue(status.IncludeRetweets);
Assert.IsTrue(status.ExcludeReplies);
Assert.IsTrue(status.IncludeEntities);
Assert.IsTrue(status.IncludeUserEntities);
Assert.IsTrue(status.TrimUser);
Assert.IsTrue(status.IncludeContributorDetails);
Assert.IsTrue(status.IncludeMyRetweet);
Assert.AreEqual("1,2,3", status.TweetIDs);
Assert.IsTrue(status.Map);
}
public void BuildUrl_Constructs_Conversations_Url()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/conversation/show.json?id=123";
var statProc = new StatusRequestProcessor <Status> {
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)StatusType.Conversation).ToString() },
{ "ID", "123" }
};
Request req = statProc.BuildUrl(parameters);
Assert.AreEqual(ExpectedUrl, req.FullUrl);
}
public void BuildUrl_Conversations_Throws_On_Missing_ID()
{
const string ExpectedParam = "ID";
var statProc = new StatusRequestProcessor <Status> {
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)StatusType.Conversation).ToString() },
//{ "ID", "123" }
};
var ex = L2TAssert.Throws <ArgumentNullException>(() => statProc.BuildUrl(parameters));
Assert.AreEqual(ExpectedParam, ex.ParamName);
}
public void BuildURLFriendTest()
{
var statProc = new StatusRequestProcessor()
{
BaseUrl = "http://twitter.com/"
};
Dictionary <string, string> parameters =
new Dictionary <string, string>
{
{ "Type", ((int)StatusType.Friends).ToString() }
};
string expected = "http://twitter.com/statuses/friends_timeline.xml";
string actual;
actual = statProc.BuildURL(parameters);
Assert.AreEqual(expected, actual);
}
public void BuildUrl_Constructs_Home_Url()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/statuses/home_timeline.json?count=5";
var reqProc = new StatusRequestProcessor <Status>
{
Type = StatusType.User,
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)StatusType.Home).ToString() },
{ "Count", "5" }
};
Request req = reqProc.BuildUrl(parameters);
Assert.Equal(ExpectedUrl, req.FullUrl);
}
public void BuildUrl_Returns_Url_For_Retweets()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/statuses/retweets/15411837.json";
var reqProc = new StatusRequestProcessor <Status>
{
Type = StatusType.User,
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)StatusType.Retweets).ToString() },
{ "ID", "15411837" }
};
Request req = reqProc.BuildUrl(parameters);
Assert.Equal(ExpectedUrl, req.FullUrl);
}
public void BuildUrl_Constructs_Url_For_RetweetedByUser()
{
const string ExpectedUrl = "http://api.twitter.com/1/statuses/retweeted_by_user.json?screen_name=JoeMayo";
var reqProc = new StatusRequestProcessor <Status>
{
Type = StatusType.RetweetedByUser,
BaseUrl = "http://api.twitter.com/1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)StatusType.RetweetedByUser).ToString() },
{ "ScreenName", "JoeMayo" }
};
Request req = reqProc.BuildUrl(parameters);
Assert.Equal(ExpectedUrl, req.FullUrl);
}
public void BuildUrl_Includes_False_IncludeUserEntities_Param()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/statuses/retweets_of_me.json?include_user_entities=false";
var reqProc = new StatusRequestProcessor <Status>
{
Type = StatusType.User,
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)StatusType.RetweetsOfMe).ToString() },
{ "IncludeUserEntities", false.ToString() },
};
Request req = reqProc.BuildUrl(parameters);
Assert.Equal(ExpectedUrl, req.FullUrl);
}
public void BuildUrl_Lookup_Throws_On_Missing_TweetIDs()
{
const string ExpectedParameterName = "TweetIDs";
var reqProc = new StatusRequestProcessor <Status>
{
Type = StatusType.Lookup,
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)StatusType.Lookup).ToString() },
//{ "TweetIDs", "1, 2, 3" },
};
var ex = L2TAssert.Throws <ArgumentNullException>(() => reqProc.BuildUrl(parameters));
Assert.AreEqual <string>(ExpectedParameterName, ex.ParamName);
}
public void BuildUrl_Lookup_Removes_Spaces_In_TweetIDs()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/statuses/lookup.json?id=1%2C2%2C3";
var reqProc = new StatusRequestProcessor <Status>
{
Type = StatusType.Lookup,
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)StatusType.Lookup).ToString() },
{ "TweetIDs", "1, 2, 3" },
};
Request req = reqProc.BuildUrl(parameters);
Assert.AreEqual(ExpectedUrl, req.FullUrl);
}
public void BuildUrl_Constructs_Mentions_Url()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/statuses/mentions_timeline.json?since_id=123&max_id=145&count=50";
var statProc = new StatusRequestProcessor <Status> {
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)StatusType.Mentions).ToString() },
{ "SinceID", "123" },
{ "MaxID", "145" },
{ "Count", "50" }
};
Request req = statProc.BuildUrl(parameters);
Assert.Equal(ExpectedUrl, req.FullUrl);
}
public void BuildUrl_Includes_False_Include_Rts_Param()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/statuses/user_timeline.json?id=15411837&include_rts=false";
var reqProc = new StatusRequestProcessor <Status>
{
Type = StatusType.User,
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)StatusType.User).ToString() },
{ "ID", "15411837" },
{ "IncludeRetweets", false.ToString() }
};
Request req = reqProc.BuildUrl(parameters);
Assert.Equal(ExpectedUrl, req.FullUrl);
}
public void BuildUrl_Constructs_Retweeters_Url()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/statuses/retweeters/ids.json?id=5&cursor=7";
var reqProc = new StatusRequestProcessor <Status>
{
Type = StatusType.User,
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)StatusType.Retweeters).ToString() },
{ "ID", "5" },
{ "Cursor", "7" }
};
Request req = reqProc.BuildUrl(parameters);
Assert.Equal(ExpectedUrl, req.FullUrl);
}
public void BuildUrl_RetweetedBy_Throws_On_Missing_ID()
{
const string ExpectedParam = "ID";
var reqProc = new StatusRequestProcessor <Status>
{
Type = StatusType.Retweeters,
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)StatusType.Retweeters).ToString() },
//{ "ID", "123" },
{ "Cursor", "25" }
};
var ex = Assert.Throws <ArgumentException>(() => reqProc.BuildUrl(parameters));
Assert.Equal(ExpectedParam, ex.ParamName);
}
public void BuildUrl_Constructs_User_Url()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/statuses/user_timeline.json?id=15411837&user_id=15411837&screen_name=JoeMayo";
var reqProc = new StatusRequestProcessor <Status>
{
Type = StatusType.User,
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)StatusType.User).ToString() },
{ "ID", "15411837" },
{ "UserID", "15411837" },
{ "ScreenName", "JoeMayo" },
};
Request req = reqProc.BuildUrl(parameters);
Assert.Equal(ExpectedUrl, req.FullUrl);
}
public void BuildUrl_Constructs_Show_Url()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/statuses/show.json?id=945932078&include_my_retweet=true&include_entities=true&trim_user=true";
var reqProc = new StatusRequestProcessor <Status>
{
Type = StatusType.Show,
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)StatusType.Show).ToString() },
{ "ID", "945932078" },
{ "TrimUser", true.ToString() },
{ "IncludeMyRetweet", true.ToString() },
{ "IncludeEntities", true.ToString() }
};
Request req = reqProc.BuildUrl(parameters);
Assert.Equal(ExpectedUrl, req.FullUrl);
}
public void BuildURLMentionsTest()
{
var statProc = new StatusRequestProcessor()
{
BaseUrl = "http://twitter.com/"
};
Dictionary <string, string> parameters =
new Dictionary <string, string>
{
{ "Type", ((int)StatusType.Mentions).ToString() },
{ "SinceID", "123" },
{ "MaxID", "145" },
{ "Count", "50" },
{ "Page", "1" }
};
string expected = "http://twitter.com/statuses/mentions.xml?since_id=123&max_id=145&count=50&page=1";
string actual;
actual = statProc.BuildURL(parameters);
Assert.AreEqual(expected, actual);
}
public void BuildUrl_Constructs_Lookup_Url()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/statuses/lookup.json?id=1%2C2%2C3&include_entities=true&trim_user=true&map=true";
var reqProc = new StatusRequestProcessor <Status>
{
Type = StatusType.Lookup,
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary <string, string>
{
{ "Type", ((int)StatusType.Lookup).ToString() },
{ "TweetIDs", "1,2,3" },
{ "IncludeEntities", true.ToString() },
{ "TrimUser", true.ToString() },
{ "Map", true.ToString() }
};
Request req = reqProc.BuildUrl(parameters);
Assert.AreEqual(ExpectedUrl, req.FullUrl);
}
public void ProcessResults_Handles_An_Embedded_Status()
{
var statProc = new StatusRequestProcessor <Status> {
Type = StatusType.Oembed, BaseUrl = "https://api.twitter.com/1.1/"
};
const string ExpectedType = "rich";
const ulong ExpectedCacheAge = 3153600000;
const string ExpectedVersion = "1.0";
const string ExpectedProviderName = "Twitter";
const string ExpectedUrl = "https://twitter.com/JoeMayo/statuses/305050067973312514";
const int ExpectedWidth = 550;
const int ExpectedHeight = 0;
const string ExpectedHtml = "some html";
const string ExpectedProviderUrl = "https://twitter.com";
const string ExpectedAuthorUrl = "https://twitter.com/JoeMayo";
const string ExpectedAuthorName = "Joe Mayo";
var statuses = statProc.ProcessResults(OEmbedResponse);
Assert.NotNull(statuses);
Assert.Single(statuses);
var status = statuses.Single();
Assert.NotNull(status);
var embeddedStatus = status.EmbeddedStatus;
Assert.NotNull(embeddedStatus);
Assert.Equal(ExpectedType, embeddedStatus.Type);
Assert.Equal(ExpectedCacheAge, embeddedStatus.CacheAge);
Assert.Equal(ExpectedVersion, embeddedStatus.Version);
Assert.Equal(ExpectedProviderName, embeddedStatus.ProviderName);
Assert.Equal(ExpectedUrl, embeddedStatus.Url);
Assert.Equal(ExpectedWidth, embeddedStatus.Width);
Assert.Equal(ExpectedHeight, embeddedStatus.Height);
Assert.Equal(ExpectedHtml, embeddedStatus.Html);
Assert.Equal(ExpectedProviderUrl, embeddedStatus.ProviderUrl);
Assert.Equal(ExpectedAuthorUrl, embeddedStatus.AuthorUrl);
Assert.Equal(ExpectedAuthorName, embeddedStatus.AuthorName);
}
/// <summary>
/// deletes a status tweet
/// </summary>
/// <param name="id">id of status tweet</param>
/// <param name="callback">Async Callback used in Silverlight queries</param>
/// <returns>deleted status tweet</returns>
public static Status DestroyStatus(this TwitterContext ctx, string id, Action<TwitterAsyncResponse<Status>> callback)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentException("id is a required parameter.", "id");
}
var destroyUrl = ctx.BaseUrl + "statuses/destroy/" + id + ".json";
var reqProc = new StatusRequestProcessor<Status>();
ITwitterExecute exec = ctx.TwitterExecutor;
exec.AsyncCallback = callback;
var resultsJson =
exec.PostToTwitter(
destroyUrl,
new Dictionary<string, string>(),
response => reqProc.ProcessActionResult(response, StatusAction.SingleStatus));
Status result = reqProc.ProcessActionResult(resultsJson, StatusAction.SingleStatus);
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);
}
public void BuildUrl_Throws_On_Null_Parameter()
{
var target = new StatusRequestProcessor<Status> { BaseUrl = "https://api.twitter.com/1.1/" };
var ex = Assert.Throws<ArgumentException>(() => target.BuildUrl(null));
Assert.Equal<string>("Type", ex.ParamName);
}
public void GetParameters_Handles_Input_Params()
{
var reqProc = new StatusRequestProcessor<Status>();
Expression<Func<Status, bool>> expression =
status =>
status.Type == StatusType.Home &&
status.ID == "10" &&
status.UserID == "10" &&
status.ScreenName == "JoeMayo" &&
status.SinceID == 123 &&
status.MaxID == 456 &&
status.Count == 50 &&
status.Page == 2 &&
status.IncludeRetweets == true &&
status.ExcludeReplies == true &&
status.IncludeEntities == true &&
status.IncludeUserEntities == true &&
status.TrimUser == true &&
status.IncludeContributorDetails == true &&
status.IncludeMyRetweet == true &&
status.OEmbedUrl == "http://myurl.com" &&
status.OEmbedAlign == EmbeddedStatusAlignment.Center &&
status.OEmbedHideMedia == true &&
status.OEmbedHideThread == true &&
status.OEmbedLanguage == "en" &&
status.OEmbedMaxWidth == 300 &&
status.OEmbedOmitScript == true &&
status.OEmbedRelated == "JoeMayo";
var lambdaExpression = expression as LambdaExpression;
var queryParams = reqProc.GetParameters(lambdaExpression);
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("Type", ((int)StatusType.Home).ToString())));
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("ID", "10")));
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("UserID", "10")));
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("ScreenName", "JoeMayo")));
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("SinceID", "123")));
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("MaxID", "456")));
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("Count", "50")));
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("Page", "2")));
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("Page", "2")));
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("IncludeRetweets", "True")));
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("ExcludeReplies", "True")));
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("IncludeUserEntities", "True")));
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("OEmbedRelated", "JoeMayo")));
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("TrimUser", "True")));
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("IncludeContributorDetails", "True")));
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("IncludeMyRetweet", "True")));
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("OEmbedUrl", "http://myurl.com")));
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("OEmbedAlign", ((int)EmbeddedStatusAlignment.Center).ToString())));
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("OEmbedHideMedia", "True")));
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("OEmbedHideThread", "True")));
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("OEmbedLanguage", "en")));
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("OEmbedMaxWidth", "300")));
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("OEmbedOmitScript", "True")));
Assert.True(
queryParams.Contains(
new KeyValuePair<string, string>("OEmbedRelated", "JoeMayo")));
}
public void BuildUrl_Constructs_Mentions_Url()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/statuses/mentions_timeline.json?since_id=123&max_id=145&count=50&page=1";
var statProc = new StatusRequestProcessor<Status> { BaseUrl = "https://api.twitter.com/1.1/" };
var parameters = new Dictionary<string, string>
{
{ "Type", ((int)StatusType.Mentions).ToString() },
{ "SinceID", "123" },
{ "MaxID", "145" },
{ "Count", "50" },
{ "Page", "1" }
};
Request req = statProc.BuildUrl(parameters);
Assert.Equal(ExpectedUrl, req.FullUrl);
}
public void BuildUrl_Constructs_Show_Url()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/statuses/show.json?id=945932078&include_my_retweet=true&include_entities=true&trim_user=true";
var reqProc = new StatusRequestProcessor<Status>
{
Type = StatusType.Show,
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary<string, string>
{
{ "Type", ((int)StatusType.Show).ToString() },
{ "ID", "945932078" },
{ "TrimUser", true.ToString() },
{ "IncludeMyRetweet", true.ToString() },
{ "IncludeEntities", true.ToString() }
};
Request req = reqProc.BuildUrl(parameters);
Assert.Equal(ExpectedUrl, req.FullUrl);
}
public void BuildUrl_Constructs_Url_For_RetweetedToUser()
{
const string ExpectedUrl = "http://api.twitter.com/1/statuses/retweeted_to_user.json?screen_name=JoeMayo";
var reqProc = new StatusRequestProcessor<Status>
{
Type = StatusType.RetweetedToUser,
BaseUrl = "http://api.twitter.com/1/"
};
var parameters = new Dictionary<string, string>
{
{ "Type", ((int)StatusType.RetweetedToUser).ToString() },
{ "ScreenName", "JoeMayo" }
};
Request req = reqProc.BuildUrl(parameters);
Assert.Equal(ExpectedUrl, req.FullUrl);
}
public async Task<Status> ReplyWithMediaAsync(ulong inReplyToStatusID, string status, bool possiblySensitive, decimal latitude, decimal longitude, string placeID, bool displayCoordinates, byte[] image, CancellationToken cancelToken = default(CancellationToken))
{
if (string.IsNullOrWhiteSpace(status))
throw new ArgumentNullException("status", "status is a required parameter.");
if (image == null || image.Length == 0)
throw new ArgumentNullException("image", "You must provide a byte[] of image data.");
string updateUrl = BaseUrl + "statuses/update_with_media.json";
string imageType = "application/octet-stream";
string name = "media[]";
string randomUnusedFileName = new Random().Next(100, 999).ToString();
var reqProc = new StatusRequestProcessor<Status>();
RawResult =
await TwitterExecutor.PostMediaAsync(
updateUrl,
new Dictionary<string, string>
{
{"status", status},
{"possibly_sensitive", possiblySensitive ? true.ToString() : null },
{"lat", latitude == NoCoordinate ? null : latitude.ToString(Culture.US) },
{"long", longitude == NoCoordinate ? null : longitude.ToString(Culture.US) },
{"place_id", string.IsNullOrWhiteSpace(placeID) ? null : placeID },
{"display_coordinates", displayCoordinates ? true.ToString() : null },
{"in_reply_to_status_id", inReplyToStatusID == NoReply ? null : inReplyToStatusID.ToString(CultureInfo.InvariantCulture)}
},
image,
name,
randomUnusedFileName,
imageType,
cancelToken)
.ConfigureAwait(false);
return reqProc.ProcessActionResult(RawResult, StatusAction.SingleStatus);
}
public void StatusRequestProcessor_Works_With_Json_Format_Data()
{
var statProc = new StatusRequestProcessor<Status> { BaseUrl = "https://api.twitter.com/1.1/" };
Assert.IsAssignableFrom<IRequestProcessorWantsJson>(statProc);
}
public void BuildUrl_Returns_Url_For_Retweets()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/statuses/retweets/15411837.json";
var reqProc = new StatusRequestProcessor<Status>
{
Type = StatusType.User,
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary<string, string>
{
{ "Type", ((int)StatusType.Retweets).ToString() },
{ "ID", "15411837" }
};
Request req = reqProc.BuildUrl(parameters);
Assert.Equal(ExpectedUrl, req.FullUrl);
}
public void BuildUrl_Returns_Url_For_IncludeRetweets_On_User_Timeline()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/statuses/user_timeline.json?id=15411837&include_rts=true";
var reqProc = new StatusRequestProcessor<Status>
{
Type = StatusType.User,
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary<string, string>
{
{ "Type", ((int)StatusType.User).ToString() },
{ "ID", "15411837" },
{ "IncludeRetweets", "True" }
};
Request req = reqProc.BuildUrl(parameters);
Assert.Equal(ExpectedUrl, req.FullUrl);
}
public void BuildUrl_Returns_Url_For_OEmbed()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/statuses/oembed.json?id=1&url=abc&maxwidth=300&hide_media=true&hide_thread=true&omit_script=true&align=left&related=JoeMayo%2CTwitterAPI&lang=en";
var reqProc = new StatusRequestProcessor<Status>
{
Type = StatusType.Oembed,
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary<string, string>
{
{ "Type", ((int)StatusType.Oembed).ToString() },
{ "ID", "1" },
{ "OEmbedUrl", "abc" },
{ "OEmbedMaxWidth", "300" },
{ "OEmbedHideMedia", true.ToString() },
{ "OEmbedHideThread", true.ToString() },
{ "OEmbedOmitScript", true.ToString() },
{ "OEmbedAlign", ((int)EmbeddedStatusAlignment.Left).ToString() },
{ "OEmbedRelated", "JoeMayo, TwitterAPI" },
{ "OEmbedLanguage", "en" }
};
Request req = reqProc.BuildUrl(parameters);
Assert.Equal(ExpectedUrl, req.FullUrl);
}
public void BuildUrl_Returns_Url_For_RetweetedBy()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/statuses/123/retweeted_by.json?count=25&page=2";
var reqProc = new StatusRequestProcessor<Status>
{
Type = StatusType.RetweetedBy,
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary<string, string>
{
{ "Type", ((int)StatusType.RetweetedBy).ToString() },
{ "ID", "123" },
{ "Count", "25" },
{ "Page", "2" }
};
Request req = reqProc.BuildUrl(parameters);
Assert.Equal(ExpectedUrl, req.FullUrl);
}
public void ProcessResults_Returns_Empty_Collection_When_Empty_Results()
{
var statProc = new StatusRequestProcessor<Status>() { BaseUrl = "https://api.twitter.com/1.1/" };
var stats = statProc.ProcessResults(string.Empty);
Assert.Equal(0, stats.Count);
}
public void StatusRequestProcessor_Handles_Actions()
{
var statusReqProc = new StatusRequestProcessor<Status>();
Assert.IsInstanceOfType(statusReqProc, typeof(IRequestProcessorWithAction<Status>));
}
public void ProcessResults_Handles_Multiple_Statuses()
{
var statProc = new StatusRequestProcessor<Status> { Type = StatusType.Home, BaseUrl = "https://api.twitter.com/1.1/" };
var statuses = statProc.ProcessResults(MultipleStatusResponse);
Assert.NotNull(statuses);
Assert.Equal(3, statuses.Count);
var status = statuses.First();
Assert.NotNull(status);
Assert.False(status.Retweeted);
Assert.Null(status.InReplyToScreenName);
Assert.False(status.PossiblySensitive);
var retweetedStatus = status.RetweetedStatus;
Assert.NotNull(retweetedStatus);
Assert.NotNull(retweetedStatus.Text);
Assert.True(retweetedStatus.Text.StartsWith("I just blogged about"));
var contributors = status.Contributors;
Assert.NotNull(contributors);
Assert.Empty(contributors);
var coords = status.Coordinates;
Assert.NotNull(coords);
Assert.Equal(-122.40060, coords.Latitude);
Assert.Equal(37.78215, coords.Longitude);
Assert.NotNull(status.Place);
Assert.Null(status.Place.Name);
Assert.NotNull(status.User);
Assert.Equal("Joe Mayo", status.User.Name);
Assert.Equal(393, status.RetweetCount);
Assert.Equal("184835136037191681", status.StatusID);
Assert.Null(status.InReplyToUserID);
Assert.False(status.Favorited);
Assert.Null(status.InReplyToStatusID);
Assert.Equal("web", status.Source);
Assert.Equal(new DateTime(2012, 3, 28, 2, 51, 45), status.CreatedAt);
Assert.Null(status.InReplyToUserID);
Assert.False(status.Truncated);
Assert.NotNull(status.Text);
Assert.True(status.Text.StartsWith("RT @scottgu: I just blogged about"));
Assert.NotNull(status.Annotation);
Assert.Empty(status.Annotation.Attributes);
Assert.NotNull(status.Entities);
Assert.Null(status.Entities.HashTagMentions);
}
/// <summary>
/// sends a status update
/// </summary>
/// <param name="status">(optional @UserName) and (required) status text</param>
/// <param name="latitude">Latitude coordinate of where tweet occurred</param>
/// <param name="longitude">Longitude coordinate of where tweet occurred</param>
/// <param name="placeID">ID of place (found via Geo Reverse lookup query)</param>
/// <param name="displayCoordinates">Allow or prevent display of coordinates for this tweet</param>
/// <param name="inReplyToStatusID">id of status replying to - optional - pass null if not used</param>
/// <param name="callback">Async Callback used in Silverlight queries</param>
/// <returns>IQueryable of sent status</returns>
public static Status UpdateStatus(this TwitterContext ctx, string status, decimal latitude, decimal longitude, string placeID, bool displayCoordinates, string inReplyToStatusID, Action<TwitterAsyncResponse<Status>> callback)
{
if (string.IsNullOrEmpty(status))
{
throw new ArgumentException("status is a required parameter.", "status");
}
var updateUrl = ctx.BaseUrl + "statuses/update.json";
var reqProc = new StatusRequestProcessor<Status>();
ITwitterExecute exec = ctx.TwitterExecutor;
exec.AsyncCallback = callback;
var resultsJson =
exec.PostToTwitter(
updateUrl,
new Dictionary<string, string>
{
{"status", status},
{"in_reply_to_status_id", inReplyToStatusID},
{"lat", latitude == -1 ? null : latitude.ToString(Culture.US)},
{"long", longitude == -1 ? null : longitude.ToString(Culture.US)},
{"place_id", placeID},
{"display_coordinates", displayCoordinates.ToString()}
},
response => reqProc.ProcessActionResult(response, StatusAction.SingleStatus));
Status result = reqProc.ProcessActionResult(resultsJson, StatusAction.SingleStatus);
return result;
}
public void BuildUrl_Constructs_Home_Url()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/statuses/home_timeline.json?count=5";
var reqProc = new StatusRequestProcessor<Status>
{
Type = StatusType.User,
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary<string, string>
{
{ "Type", ((int)StatusType.Home).ToString() },
{ "Count", "5" }
};
Request req = reqProc.BuildUrl(parameters);
Assert.Equal(ExpectedUrl, req.FullUrl);
}
public void ProcessResults_Populates_EmbeddedStatus_Parameters()
{
var statProc = new StatusRequestProcessor<Status>()
{
BaseUrl = "https://api.twitter.com/1.1/",
Type = StatusType.Oembed,
ID = "123",
OEmbedUrl = "http://myurl.com",
OEmbedMaxWidth = 300,
OEmbedHideMedia = true,
OEmbedHideThread = true,
OEmbedOmitScript = true,
OEmbedAlign = EmbeddedStatusAlignment.Left,
OEmbedRelated = "JoeMayo,TwitterAPI",
OEmbedLanguage = "en"
};
var statuses = statProc.ProcessResults(OEmbedResponse);
Assert.NotNull(statuses);
Assert.Single(statuses);
var status = statuses.Single();
Assert.NotNull(status);
Assert.Equal(StatusType.Oembed, status.Type);
Assert.Equal("123", status.ID);
Assert.Equal("http://myurl.com", status.OEmbedUrl);
Assert.Equal(300, status.OEmbedMaxWidth);
Assert.True(status.OEmbedHideMedia);
Assert.True(status.OEmbedHideThread);
Assert.True(status.OEmbedOmitScript);
Assert.Equal(EmbeddedStatusAlignment.Left, status.OEmbedAlign);
Assert.Equal("JoeMayo,TwitterAPI", status.OEmbedRelated);
Assert.Equal("en", status.OEmbedLanguage);
}
public void BuildUrl_Includes_False_IncludeUserEntities_Param()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/statuses/retweets_of_me.json?include_user_entities=false";
var reqProc = new StatusRequestProcessor<Status>
{
Type = StatusType.User,
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary<string, string>
{
{ "Type", ((int)StatusType.RetweetsOfMe).ToString() },
{ "IncludeUserEntities", false.ToString() },
};
Request req = reqProc.BuildUrl(parameters);
Assert.Equal(ExpectedUrl, req.FullUrl);
}
public void ProcessResults_Handles_Multiple_Users()
{
var statProc = new StatusRequestProcessor<Status> { Type = StatusType.RetweetedBy, BaseUrl = "https://api.twitter.com/1.1/" };
var statuses = statProc.ProcessResults(MultipleUsersResponse);
Assert.NotNull(statuses);
Assert.Single(statuses);
var status = statuses.Single();
Assert.NotNull(status);
var users = status.Users;
Assert.NotNull(users);
Assert.Equal(5, users.Count);
var user = users.First();
Assert.NotNull(user.Identifier);
Assert.Equal("gcaughey", user.Identifier.ScreenName);
}
public void BuildUrl_Constructs_User_Url()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/statuses/user_timeline.json?id=15411837&user_id=15411837&screen_name=JoeMayo";
var reqProc = new StatusRequestProcessor<Status>
{
Type = StatusType.User,
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary<string, string>
{
{ "Type", ((int)StatusType.User).ToString() },
{ "ID", "15411837" },
{ "UserID", "15411837" },
{ "ScreenName", "JoeMayo" },
};
Request req = reqProc.BuildUrl(parameters);
Assert.Equal(ExpectedUrl, req.FullUrl);
}
public void ProcessResults_Handles_An_Embedded_Status()
{
var statProc = new StatusRequestProcessor<Status> { Type = StatusType.Oembed, BaseUrl = "https://api.twitter.com/1.1/" };
const string ExpectedType = "rich";
const string ExpectedCacheAge = "31536000000";
const string ExpectedVersion = "1.0";
const string ExpectedProviderName = "Twitter";
const string ExpectedUrl = "https://twitter.com/JoeMayo/status/305050067973312514";
const int ExpectedWidth = 550;
const int ExpectedHeight = 0;
const string ExpectedHtml = "some html";
const string ExpectedProviderUrl = "http://twitter.com";
const string ExpectedAuthorUrl = "https://twitter.com/JoeMayo";
const string ExpectedAuthorName = "Joe Mayo";
var statuses = statProc.ProcessResults(OEmbedResponse);
Assert.NotNull(statuses);
Assert.Single(statuses);
var status = statuses.Single();
Assert.NotNull(status);
var embeddedStatus = status.EmbeddedStatus;
Assert.NotNull(embeddedStatus);
Assert.Equal(ExpectedType, embeddedStatus.Type);
Assert.Equal(ExpectedCacheAge, embeddedStatus.CacheAge);
Assert.Equal(ExpectedVersion, embeddedStatus.Version);
Assert.Equal(ExpectedProviderName, embeddedStatus.ProviderName);
Assert.Equal(ExpectedUrl, embeddedStatus.Url);
Assert.Equal(ExpectedWidth, embeddedStatus.Width);
Assert.Equal(ExpectedHeight, embeddedStatus.Height);
Assert.Equal(ExpectedHtml, embeddedStatus.Html);
Assert.Equal(ExpectedProviderUrl, embeddedStatus.ProviderUrl);
Assert.Equal(ExpectedAuthorUrl, embeddedStatus.AuthorUrl);
Assert.Equal(ExpectedAuthorName, embeddedStatus.AuthorName);
}
/// <summary>
/// sends a status update with attached media
/// </summary>
/// <param name="twitterCtx">Your instance of TwitterContext</param>
/// <param name="inReplyToStatusID">id of status replying to - optional - pass null if not used</param>
/// <param name="status">(optional @UserName) and (required) status text</param>
/// <param name="possiblySensitive">Set to true if media does not contain age appropriate content</param>
/// <param name="latitude">Latitude coordinate of where tweet occurred</param>
/// <param name="longitude">Longitude coordinate of where tweet occurred</param>
/// <param name="placeID">ID of place (found via Geo Reverse lookup query)</param>
/// <param name="displayCoordinates">Allow or prevent display of coordinates for this tweet</param>
/// <param name="mediaItems">List of Media to send</param>
/// <param name="callback">Async callback handler</param>
/// <returns>Status containing new reply</returns>
public static Status ReplyWithMedia(this TwitterContext twitterCtx, ulong inReplyToStatusID, string status, bool possiblySensitive, decimal latitude, decimal longitude, string placeID, bool displayCoordinates, List<Media> mediaItems, Action<TwitterAsyncResponse<Status>> callback)
{
if (string.IsNullOrEmpty(status))
{
throw new ArgumentNullException("status", "status is a required parameter.");
}
if (mediaItems == null)
{
throw new ArgumentNullException("mediaItems", "You must pass at least one Media in mediaItems.");
}
if (mediaItems.Count == 0)
{
throw new ArgumentException("You must pass at least one Media in mediaItems.", "mediaItems");
}
twitterCtx.TwitterExecutor.AsyncCallback = callback;
var updateUrl = twitterCtx.BaseUrl + "statuses/update_with_media.json";
var reqProc = new StatusRequestProcessor<Status>();
string resultString =
twitterCtx.TwitterExecutor.PostMedia(
updateUrl,
new Dictionary<string, string>
{
{"status", status},
{"possibly_sensitive", possiblySensitive ? true.ToString() : null },
{"lat", latitude == NoCoordinate ? null : latitude.ToString(Culture.US) },
{"long", longitude == NoCoordinate ? null : longitude.ToString(Culture.US) },
{"place_id", string.IsNullOrEmpty(placeID) ? null : placeID },
{"display_coordinates", displayCoordinates ? true.ToString() : null },
{"in_reply_to_status_id", inReplyToStatusID == NoReply ? null : inReplyToStatusID.ToString(CultureInfo.InvariantCulture)}
},
mediaItems,
reqProc);
Status result = reqProc.ProcessActionResult(resultString, StatusAction.SingleStatus);
return result;
}
public void BuildUrl_Returns_Url_For_RetweetsOfMe()
{
const string ExpectedUrl = "https://api.twitter.com/1.1/statuses/retweets_of_me.json?since_id=2&max_id=3&count=1&include_entities=true&include_user_entities=true&trim_user=true";
var reqProc = new StatusRequestProcessor<Status>
{
Type = StatusType.Oembed,
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary<string, string>
{
{ "Type", ((int)StatusType.RetweetsOfMe).ToString() },
{ "Count", "1" },
{ "SinceID", "2" },
{ "MaxID", "3" },
{ "TrimUser", true.ToString() },
{ "IncludeEntities", true.ToString() },
{ "IncludeUserEntities", true.ToString() },
};
Request req = reqProc.BuildUrl(parameters);
Assert.Equal(ExpectedUrl, req.FullUrl);
}
public void BuildUrl_RetweetedBy_Throws_On_Missing_ID()
{
const string ExpectedParam = "ID";
var reqProc = new StatusRequestProcessor<Status>
{
Type = StatusType.RetweetedBy,
BaseUrl = "https://api.twitter.com/1.1/"
};
var parameters = new Dictionary<string, string>
{
{ "Type", ((int)StatusType.RetweetedBy).ToString() },
//{ "ID", "123" },
{ "Count", "25" },
{ "Page", "2" }
};
var ex = Assert.Throws<ArgumentException>(() => reqProc.BuildUrl(parameters));
Assert.Equal(ExpectedParam, ex.ParamName);
}
public void ProcessResults_Populates_Input_Parameters()
{
var statProc = new StatusRequestProcessor<Status>()
{
BaseUrl = "https://api.twitter.com/1.1/",
Type = StatusType.Show,
ID = "123",
UserID = "123",
ScreenName = "abc",
SinceID = 1,
MaxID = 2,
Count = 3,
Page = 4,
IncludeRetweets = true,
ExcludeReplies = true,
IncludeEntities = true,
IncludeUserEntities = true,
TrimUser = true,
IncludeContributorDetails = true,
IncludeMyRetweet = true,
};
var statuses = statProc.ProcessResults(SingleStatusResponse);
Assert.NotNull(statuses);
Assert.Single(statuses);
var status = statuses.Single();
Assert.NotNull(status);
Assert.Equal(StatusType.Show, status.Type);
Assert.Equal("123", status.ID);
Assert.Equal("123", status.UserID);
Assert.Equal("abc", status.ScreenName);
Assert.Equal(1ul, status.SinceID);
Assert.Equal(2ul, status.MaxID);
Assert.Equal(3, status.Count);
Assert.Equal(4, status.Page);
Assert.True(status.IncludeRetweets);
Assert.True(status.ExcludeReplies);
Assert.True(status.IncludeEntities);
Assert.True(status.IncludeUserEntities);
Assert.True(status.TrimUser);
Assert.True(status.IncludeContributorDetails);
Assert.True(status.IncludeMyRetweet);
}
