/// <summary>
/// deletes a direct message
/// </summary>
/// <param name="ctx">Twitter Context</param>
/// <param name="id">id of direct message</param>
/// <param name="callback">Async Callback</param>
/// <returns>direct message element</returns>
public static DirectMessage DestroyDirectMessage(this TwitterContext ctx, string id, bool includeEntites, Action<TwitterAsyncResponse<DirectMessage>> callback)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentException("id is a required parameter.", "id");
}
var destroyUrl = ctx.BaseUrl + "direct_messages/destroy.json";
var reqProc = new DirectMessageRequestProcessor<DirectMessage>();
var twitExe = ctx.TwitterExecutor;
twitExe.AsyncCallback = callback;
var resultsJson =
twitExe.PostToTwitter(
destroyUrl,
new Dictionary<string, string>
{
{"id", id},
{"include_entities", includeEntites.ToString().ToLower()}
},
response => reqProc.ProcessActionResult(response, DirectMessageType.Show));
DirectMessage dm = reqProc.ProcessActionResult(resultsJson, DirectMessageType.Show);
return dm;
}
/// <summary>
/// Sends a new direct message to specified user.
/// </summary>
/// <param name="userID">User ID of user to send to.</param>
/// <param name="text">Direct message contents.</param>
/// <returns>Direct message element.</returns>
public async Task<DirectMessage> NewDirectMessageAsync(ulong userID, string text, CancellationToken cancelToken = default(CancellationToken))
{
if (userID == 0)
throw new ArgumentException("userID must be set.", "userID");
if (string.IsNullOrWhiteSpace(text))
throw new ArgumentException("text is a required parameter.", "text");
var newUrl = BaseUrl + "direct_messages/new.json";
var reqProc = new DirectMessageRequestProcessor<DirectMessage>();
RawResult =
await TwitterExecutor.PostToTwitterAsync<DirectMessage>(
newUrl,
new Dictionary<string, string>
{
{"user_id", userID.ToString()},
{"text", text}
},
cancelToken)
.ConfigureAwait(false);
return reqProc.ProcessActionResult(RawResult, DirectMessageType.Show);
}
/// <summary>
/// sends a new direct message to specified userr
/// </summary>
/// <param name="ctx">Twitter Context</param>
/// <param name="user">UserID or ScreenName of user to send to</param>
/// <param name="text">Direct message contents</param>
/// <param name="wrapLinks">Shorten links using Twitter's t.co wrapper</param>
/// <param name="callback">Async Callback</param>
/// <returns>Direct message element</returns>
public static DirectMessage NewDirectMessage(this TwitterContext ctx, string user, string text, Action<TwitterAsyncResponse<DirectMessage>> callback)
{
if (string.IsNullOrEmpty(user))
{
throw new ArgumentException("user is a required parameter.", "user");
}
if (string.IsNullOrEmpty(text))
{
throw new ArgumentException("text is a required parameter.", "text");
}
var newUrl = ctx.BaseUrl + "direct_messages/new.json";
var reqProc = new DirectMessageRequestProcessor<DirectMessage>();
var twitExe = ctx.TwitterExecutor;
twitExe.AsyncCallback = callback;
var resultsJson =
twitExe.PostToTwitter(
newUrl,
new Dictionary<string, string>
{
{"user", user},
{"text", text}
},
response => reqProc.ProcessActionResult(response, DirectMessageType.Show));
DirectMessage dm = reqProc.ProcessActionResult(resultsJson, DirectMessageType.Show);
return dm;
}
public void BuildUrl_Show_Requires_ID()
{
var dmReqProc = new DirectMessageRequestProcessor<DirectMessage> { BaseUrl = "https://api.twitter.com/1/" };
var parameters =
new Dictionary<string, string>
{
{ "Type", ((int)DirectMessageType.Show).ToString(CultureInfo.InvariantCulture) },
//{ "ID", "478805447" },
};
ArgumentNullException ex = L2TAssert.Throws<ArgumentNullException>(() => dmReqProc.BuildUrl(parameters));
Assert.AreEqual("ID", ex.ParamName);
}
public void BuildUrl_Constructs_Show_Url()
{
var dmReqProc = new DirectMessageRequestProcessor<DirectMessage> { BaseUrl = "https://api.twitter.com/1/" };
const string Expected = "https://api.twitter.com/1/direct_messages/show.json?id=478805447";
var parameters =
new Dictionary<string, string>
{
{ "Type", ((int)DirectMessageType.Show).ToString(CultureInfo.InvariantCulture) },
{ "ID", "478805447" },
};
Request req = dmReqProc.BuildUrl(parameters);
Assert.Equal(Expected, req.FullUrl);
}
public void BuildUrl_Constructs_SentBy_Url()
{
var dmReqProc = new DirectMessageRequestProcessor<DirectMessage> { BaseUrl = "https://api.twitter.com/1/" };
const string Expected = "https://api.twitter.com/1/direct_messages/sent.json?since_id=1234567&max_id=357&page=1&count=2&include_entities=true";
var parameters =
new Dictionary<string, string>
{
{ "Type", ((int)DirectMessageType.SentBy).ToString(CultureInfo.InvariantCulture) },
{ "SinceID", "1234567" },
{ "MaxID", "357" },
{ "Page", "1" },
{ "Count", "2" },
{ "IncludeEntities", true.ToString() }
};
Request req = dmReqProc.BuildUrl(parameters);
Assert.Equal(Expected, req.FullUrl);
}
public void GetParametersTest()
{
var dmProc = new DirectMessageRequestProcessor <DirectMessage>();
var ctx = new TwitterContext();
var directMessages =
from tweet in ctx.DirectMessage
where tweet.Type == DirectMessageType.SentTo
select tweet;
var whereFinder = new FirstWhereClauseFinder();
var whereExpression = whereFinder.GetFirstWhere(directMessages.Expression);
var lambdaExpression = (LambdaExpression)((UnaryExpression)(whereExpression.Arguments[1])).Operand;
lambdaExpression = (LambdaExpression)Evaluator.PartialEval(lambdaExpression);
var queryParams = dmProc.GetParameters(lambdaExpression);
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair <string, string>("Type", ((int)DirectMessageType.SentTo).ToString())));
}
public void BuildUrl_Constructs_SentBy_Url()
{
var dmReqProc = new DirectMessageRequestProcessor <DirectMessage> {
BaseUrl = "https://api.twitter.com/1/"
};
const string Expected = "https://api.twitter.com/1/direct_messages/sent.json?since_id=1234567&max_id=357&page=1&count=2&include_entities=true&full_text=true";
var parameters =
new Dictionary <string, string>
{
{ "Type", ((int)DirectMessageType.SentBy).ToString(CultureInfo.InvariantCulture) },
{ "SinceID", "1234567" },
{ "MaxID", "357" },
{ "Page", "1" },
{ "Count", "2" },
{ "IncludeEntities", true.ToString() },
{ "FullText", true.ToString() }
};
Request req = dmReqProc.BuildUrl(parameters);
Assert.AreEqual(Expected, req.FullUrl);
}
public void ProcessResultsTest()
{
var dmProc = new DirectMessageRequestProcessor<DirectMessage>() { BaseUrl = "http://twitter.com/" };
XElement twitterResponse = XElement.Load(new StringReader(m_testQueryResponse));
var actual = dmProc.ProcessResults(twitterResponse);
var actualQuery = actual as IList<DirectMessage>;
Assert.IsNotNull(actualQuery);
Assert.AreEqual(1 ,actualQuery.Count());
}
public void BuildUrl_Throws_On_Missing_Type_Param()
{
var dmReqProc = new DirectMessageRequestProcessor<DirectMessage> { BaseUrl = "https://api.twitter.com/1/" };
var parameters = new Dictionary<string, string>();
ArgumentException ex = L2TAssert.Throws<ArgumentException>(() => dmReqProc.BuildUrl(parameters));
Assert.AreEqual("Type", ex.ParamName);
}
public void BuildUrl_Throws_On_Null_Param_Dictionary()
{
var dmReqProc = new DirectMessageRequestProcessor<DirectMessage> { BaseUrl = "https://api.twitter.com/1/" };
ArgumentException ex = L2TAssert.Throws<ArgumentException>(() => dmReqProc.BuildUrl(null));
Assert.AreEqual("Type", ex.ParamName);
}
public void ProcessResults_Replaces_Input_Params_For_SentBy_And_SentTo()
{
const ulong SinceID = 1;
const ulong MaxID = 2;
const int Page = 3;
const int Count = 4;
const ulong ID = 5;
const bool SkipStatus = true;
var dmReqProc = new DirectMessageRequestProcessor<DirectMessage>
{
BaseUrl = "https://api.twitter.com/1/",
Type = DirectMessageType.SentBy,
SinceID = SinceID,
MaxID = MaxID,
Page = Page,
Count = Count,
ID = ID,
SkipStatus = SkipStatus
};
List<DirectMessage> dms = dmReqProc.ProcessResults(TestQueryResponse);
DirectMessage dm = dms.First();
Assert.AreEqual(SinceID, dm.SinceID);
Assert.AreEqual(MaxID, dm.MaxID);
Assert.AreEqual(Page, dm.Page);
Assert.AreEqual(Count, dm.Count);
Assert.AreEqual(ID, dm.ID);
Assert.AreEqual(SkipStatus, SkipStatus);
}
public void GetParameters_Returns_Parameters()
{
var dmReqProc = new DirectMessageRequestProcessor<DirectMessage>();
Expression<Func<DirectMessage, bool>> expression =
dm =>
dm.Type == DirectMessageType.Show &&
dm.Count == 1 &&
dm.MaxID == 789 &&
dm.Page == 1 &&
dm.SinceID == 123 &&
dm.ID == 456 &&
dm.IncludeEntities == true &&
dm.SkipStatus == true &&
dm.FullText == true;
var lambdaExpression = expression as LambdaExpression;
Dictionary<string, string> queryParams = dmReqProc.GetParameters(lambdaExpression);
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("Type", ((int)DirectMessageType.Show).ToString(CultureInfo.InvariantCulture))));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("Count", "1")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("MaxID", "789")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("Page", "1")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("SinceID", "123")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("ID", "456")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("IncludeEntities", "True")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("SkipStatus", "True")));
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("FullText", "True")));
}
public void ProcessResults_Returns_Empty_Collection_When_Empty_Results()
{
var dmReqProc = new DirectMessageRequestProcessor<DirectMessage> { BaseUrl = "https://api.twitter.com/1/" };
List<DirectMessage> dms = dmReqProc.ProcessResults(string.Empty);
Assert.IsFalse(dms.Any());
}
public void ProcessResults_Handles_Single_Result_For_Show()
{
var dmReqProc = new DirectMessageRequestProcessor<DirectMessage>
{
BaseUrl = "https://api.twitter.com/1/",
Type = DirectMessageType.Show
};
List<DirectMessage> dms = dmReqProc.ProcessResults(TestQuerySingleResponse);
Assert.IsNotNull(dms.SingleOrDefault());
}
public void NullParametersTest()
{
DirectMessageRequestProcessor<DirectMessage> target = new DirectMessageRequestProcessor<DirectMessage>() { BaseUrl = "http://twitter.com/" };
Dictionary<string, string> parameters = null;
string actual;
try
{
actual = target.BuildURL(parameters);
Assert.Fail("Expected ArgumentException.");
}
catch (ArgumentException ae)
{
Assert.AreEqual<string>("Type", ae.ParamName);
}
}
public void DirectMessageRequestProcessor_Works_With_Actions()
{
var dmReqProc = new DirectMessageRequestProcessor <DirectMessage>();
Assert.IsAssignableFrom <IRequestProcessorWithAction <DirectMessage> >(dmReqProc);
}
public void BuildUrlSentToSinceIDTest()
{
var dmProc = new DirectMessageRequestProcessor<DirectMessage>() { BaseUrl = "http://twitter.com/" };
string expected = "http://twitter.com/direct_messages.xml?since_id=1234567&max_id=357&page=1&count=2";
Dictionary<string, string> parameters =
new Dictionary<string, string>
{
{ "Type", ((int)DirectMessageType.SentTo).ToString() },
{ "SinceID", "1234567" },
{ "MaxID", "357" },
{ "Page", "1" },
{ "Count", "2" }
};
string actual = dmProc.BuildURL(parameters);
Assert.AreEqual(expected, actual);
}
public void ProcessResults_Handles_Response()
{
var dmReqProc = new DirectMessageRequestProcessor<DirectMessage> { BaseUrl = "https://api.twitter.com/1/" };
List<DirectMessage> actual = dmReqProc.ProcessResults(TestQueryResponse);
var actualQuery = actual as IList<DirectMessage>;
Assert.IsNotNull(actualQuery);
Assert.AreEqual(1, actualQuery.Count());
}
/// <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);
}
public void DirectMessageRequestProcessor_Works_With_Actions()
{
var dmReqProc = new DirectMessageRequestProcessor<DirectMessage>();
Assert.IsAssignableFrom<IRequestProcessorWithAction<DirectMessage>>(dmReqProc);
}
public void GetParametersTest()
{
var dmProc = new DirectMessageRequestProcessor<DirectMessage>();
var ctx = new TwitterContext();
var directMessages =
from tweet in ctx.DirectMessage
where tweet.Type == DirectMessageType.SentTo
select tweet;
var whereFinder = new FirstWhereClauseFinder();
var whereExpression = whereFinder.GetFirstWhere(directMessages.Expression);
var lambdaExpression = (LambdaExpression)((UnaryExpression)(whereExpression.Arguments[1])).Operand;
lambdaExpression = (LambdaExpression)Evaluator.PartialEval(lambdaExpression);
var queryParams = dmProc.GetParameters(lambdaExpression);
Assert.IsTrue(
queryParams.Contains(
new KeyValuePair<string, string>("Type", ((int)DirectMessageType.SentTo).ToString())));
}
public void DirectMessageRequestProcessor_Works_With_Actions()
{
var dmReqProc = new DirectMessageRequestProcessor <DirectMessage>();
Assert.IsInstanceOfType(dmReqProc, typeof(IRequestProcessorWithAction <DirectMessage>));
}
public void DirectMessageRequestProcessor_Works_With_Actions()
{
var dmReqProc = new DirectMessageRequestProcessor<DirectMessage>();
Assert.IsInstanceOfType(dmReqProc, typeof(IRequestProcessorWithAction<DirectMessage>));
}
