protected async Task PublishReplyTweet(string text, long replyTo)
{
try
{
var tweetText = StringUtils.RemoveMentions(text);
var publishTweetsParameters = new PublishTweetParameters(text)
{
InReplyToTweetId = replyTo
};
var replyTweet = await TwitterClient.Tweets.PublishTweetAsync(publishTweetsParameters);
if (replyTweet == null)
{
Logger.LogWarning("Not able to tweet Reply", text);
return;
}
Logger.LogInformation("Reply sent successfuly");
await TwitterLogService.LogReply(replyTweet.Id, replyTo, replyTweet.Text);
}
catch (TwitterException ex) when(ex.ToString().Contains("The original Tweet author restricted who can reply to this Tweet") ||
ex.ToString().Contains("Status is a duplicate") ||
ex.ToString().Contains("blocked from the author of this tweet"))
{
Logger.LogWarning(ex, $"Error sending reply to {replyTo}");
}
}
public async void PublishTweet(string text, string imageUrl = null)
{
var publishTweetParameters = new PublishTweetParameters(text);
if (string.IsNullOrWhiteSpace(imageUrl) == false)
{
var response = await WebRequest.Create(imageUrl).GetResponseAsync();
var allBytes = new List <byte>();
using (var imageStream = response.GetResponseStream())
{
byte[] buffer = new byte[4000];
int bytesRead;
while ((bytesRead = await imageStream.ReadAsync(buffer, 0, 4000)) > 0)
{
allBytes.AddRange(buffer.Take(bytesRead));
}
}
var media = await _userClient.Upload.UploadBinaryAsync(allBytes.ToArray());
publishTweetParameters = new PublishTweetParameters(text)
{
Medias = new List <IMedia> {
media
}
};
}
await _userClient.Tweets.PublishTweetAsync(publishTweetParameters);
}
public ITweet PublishTweet(string text, IPublishTweetOptionalParameters optionalParameters = null)
{
var parameters = new PublishTweetParameters(text, optionalParameters);
var tweetDTO = InternalPublishTweet(parameters);
return(_tweetFactory.GenerateTweetFromDTO(tweetDTO));
}
private async Task TryPublishImage()
{
try
{
var random = new Random();
var stream = new MemoryStream();
var pictureToPost = await _imageService.GetPostableImage();
pictureToPost.Object.SaveAsJpeg(stream);
var symbol = _symbols[random.Next(0, _symbols.Length - 1)];
var coordinates = new Coordinates(pictureToPost.Latitude, pictureToPost.Longtitude);
var mapsLink = $"https://www.google.com/maps/@{coordinates.Latitude:0.########},{coordinates.Longitude:0.########},{pictureToPost.Zoom - 1}z/data=!3m1!1e3";
var parameters =
new PublishTweetParameters(
$"{symbol} ({coordinates.Latitude:0.######}, {coordinates.Longitude:0.######})\n\n{mapsLink}")
{
MediaBinaries = { stream.ToArray() }, Coordinates = coordinates
};
_logger.LogInformation($"Tweeting {parameters.Text}");
Tweet.PublishTweet(parameters);
}
catch (Exception e)
{
_logger.LogError(e.Message);
}
}
public async Task <bool> SendMessageAsync(string message)
{
var tweetParams = new PublishTweetParameters()
{
Text = message
};
await _twitterClient.Tweets.PublishTweetAsync(tweetParams).FreeContext();
return(true);
}
public async Task <Tweetinvi.Models.ITweet> ReplyTweetV2(long tweetId, string text)
{
var tweet = await _client.Tweets.GetTweetAsync(tweetId);
var parameters = new PublishTweetParameters($"@{tweet.CreatedBy} {text}")
{
InReplyToTweet = tweet
};
return(await _client.Tweets.PublishTweetAsync(parameters));
}
public void SimplePublishTweetQuery_ReturnsExpectedQuery()
{
// Arrange
var queryGenerator = CreateUserQueryGenerator();
var parameters = new PublishTweetParameters("hello");
// Act
var result = queryGenerator.GetPublishTweetQuery(parameters, null);
// Assert
Assert.Equal(result, $"https://api.twitter.com/1.1/statuses/update.json?status=hello");
}
public bool PublishTweet(ITweet tweet, IPublishTweetOptionalParameters optionalParameters = null)
{
if (tweet == null)
{
throw new ArgumentException("Tweet cannot be null!");
}
var parameters = new PublishTweetParameters(tweet.Text, optionalParameters);
var tweetDTO = InternalPublishTweet(parameters);
UpdateTweetIfTweetSuccessfullyBeenPublished(tweet, tweetDTO);
return(tweet.IsTweetPublished);
}
public async Task <ITweet> PostReplyAsync(ITweet inReplyTo, string message, string videoAttachmentUri, bool adult)
{
ITweet reply = null;
try
{
var publishParameters = new PublishTweetParameters(message)
{
InReplyToTweet = inReplyTo,
PossiblySensitive = adult
};
if (videoAttachmentUri != null)
{
var video = await videoAttachmentUri.GetBytesAsync();
var upload = await _client.Upload.UploadTweetVideoAsync(video);
await _client.Upload.WaitForMediaProcessingToGetAllMetadataAsync(upload);
publishParameters.Medias = new List <IMedia> {
upload
};
}
reply = await _client.Tweets.PublishTweetAsync(publishParameters);
Log.Information("Reply sent to {Author}", inReplyTo.CreatedBy.ScreenName);
}
catch (Exception e)
{
Log.Error(e, "Error submitting reply");
}
try
{
var entry = new MentionEntry()
{
TweetId = inReplyTo.Id,
Status = reply == null ? MentionStatus.Error : MentionStatus.Replied,
Timestamp = reply?.CreatedAt.DateTime ?? DateTime.Now
};
_repository.Save(entry);
}
catch (Exception e)
{
Log.Error(e, "Failed to persist MentionEntry");
}
return(reply);
}
public string PublishTweet(string text, IPublishTweetOptionalParameters optionalParameters = null)
{
// The exceptions have to be raised before the QueryGenerator as
// We do not want to wait for the media to be uploaded to throw the
// Exception. And The logic of uploading the media should live in
// the TweetController
var publishParameter = new PublishTweetParameters(text, optionalParameters);
_tweetQueryValidator.ThrowIfTweetCannotBePublished(publishParameter);
_tweetController.UploadMedias(publishParameter);
var query = _tweetQueryGenerator.GetPublishTweetQuery(publishParameter);
return(_twitterAccessor.ExecuteJsonPOSTQuery(query));
}
public async Task PublishTweet_ReturnsQueryExecutorResultAsync()
{
// Arrange
var controller = CreateTweetController();
var parameters = new PublishTweetParameters("hello");
var request = A.Fake <ITwitterRequest>();
var expectedResult = A.Fake <ITwitterResult <ITweetDTO> >();
A.CallTo(() => _fakeTweetQueryExecutor.PublishTweetAsync(parameters, request)).Returns(expectedResult);
// Act
var result = await controller.PublishTweetAsync(parameters, request);
// Assert
Assert.Equal(result, expectedResult);
}
public async Task <Uri> CreateTweet(string tweetText, byte[] image)
{
ITwitterClient client = new TwitterClient(_credentials);
var publishTweetParameters = new PublishTweetParameters(tweetText);
if (image != null)
{
var media = await client.Upload.UploadBinaryAsync(image);
publishTweetParameters.Medias.Add(media);
}
var publishedTweet = await client.Tweets.PublishTweetAsync(publishTweetParameters);
return(new Uri(publishedTweet.Url));
}
public OperationResult SendTweet(string message)
{
OperationResult result = new OperationResult();
try
{
Auth.SetUserCredentials(_consumerKey, _consumerSecret, _accessToken, _accessTokenSecret);
IPublishTweetParameters tweetParams = new PublishTweetParameters(message);
var tweet = Tweetinvi.Tweet.PublishTweet(tweetParams);
}
catch (Exception ex)
{
result.FromException(ex);
}
return(result);
}
public void PublishTweetQuery_ReturnsExpectedQuery()
{
// Arrange
var queryGenerator = CreateUserQueryGenerator();
var quotedAuthor = A.Fake <IUser>();
A.CallTo(() => quotedAuthor.ScreenName).Returns("quoted_author");
var quotedTweet = A.Fake <ITweet>();
A.CallTo(() => quotedTweet.Id).Returns(48);
A.CallTo(() => quotedTweet.CreatedBy).Returns(quotedAuthor);
var parameters = new PublishTweetParameters("hello")
{
Coordinates = new Coordinates(42, 43),
MediaIds = new List <long> {
44, 51
},
PlaceId = "place",
PossiblySensitive = false,
DisplayExactCoordinates = true,
AutoPopulateReplyMetadata = true,
ExcludeReplyUserIds = new long[] { 45, 50 },
InReplyToTweetId = 46,
QuotedTweet = quotedTweet,
TrimUser = true,
CardUri = "cardUri",
CustomQueryParameters = { new Tuple <string, string>("hello", "world") }
};
// Act
var result = queryGenerator.GetPublishTweetQuery(parameters, TweetMode.Extended);
// Assert
var url = "https://api.twitter.com/1.1/statuses/update.json?status=hello&auto_populate_reply_metadata=true&" +
$"attachment_url={Uri.EscapeDataString("https://twitter.com/quoted_author/status/48")}&" +
"card_uri=cardUri&display_coordinates=true&exclude_reply_user_ids=45%2C50&" +
"in_reply_to_status_id=46&lat=42&long=43&media_ids=44%2C51&" +
"place_id=place&possibly_sensitive=false&trim_user=true&tweet_mode=extended&hello=world";
Assert.Equal(result, url);
}
public async Task <ActionResult> Index(string tweet, IFormFile file)
{
var fileBytes = GetByteArrayFromFile(file);
var client = new TwitterClient(_credentials);
try
{
var publishTweetParameters = new PublishTweetParameters(tweet);
if (fileBytes != null)
{
var media = await client.Upload.UploadBinaryAsync(fileBytes);
publishTweetParameters.Medias.Add(media);
}
var publishedTweet = await client.Tweets.PublishTweetAsync(publishTweetParameters);
var routeValueParameters = new Dictionary <string, object>
{
{ "id", publishedTweet?.Id },
{ "author", publishedTweet?.CreatedBy.ScreenName },
{ "actionPerformed", "Publish" },
{ "success", publishedTweet != null }
};
return(RedirectToAction("TweetPublished", routeValueParameters));
}
catch (Exception)
{
var routeValueParameters = new Dictionary <string, object>
{
{ "id", null },
{ "author", null },
{ "actionPerformed", "Publish" },
{ "success", false }
};
return(RedirectToAction("TweetPublished", routeValueParameters));
}
}
public async Task PublishTweet_ReturnsFavoritedTweetsAsync()
{
// Arrange
var queryExecutor = CreateUserQueryExecutor();
var expectedQuery = TestHelper.GenerateString();
var parameters = new PublishTweetParameters("hello");
var request = A.Fake <ITwitterRequest>();
var expectedResult = A.Fake <ITwitterResult <ITweetDTO> >();
A.CallTo(() => _fakeTweetQueryGenerator.GetPublishTweetQuery(parameters, It.IsAny <TweetMode?>())).Returns(expectedQuery);
A.CallTo(() => _fakeTwitterAccessor.ExecuteRequestAsync <ITweetDTO>(request)).Returns(expectedResult);
// Act
var result = await queryExecutor.PublishTweetAsync(parameters, request);
// Assert
Assert.Equal(result, expectedResult);
Assert.Equal(request.Query.Url, expectedQuery);
Assert.Equal(HttpMethod.POST, request.Query.HttpMethod);
}
public async Task <ActionResult> Publish(string tweet, HttpPostedFileBase file)
{
var routeValueParameters = new RouteValueDictionary();
var fileBytes = GetByteArrayFromFile(file);
if (MyCredentials.LastAuthenticatedCredentials == null)
{
return(RedirectToAction("Index", routeValueParameters));
}
if (tweet == null && fileBytes == null)
{
routeValueParameters.Add("info", "You must specify either ");
return(RedirectToAction("Index", routeValueParameters));
}
try
{
var client = new TwitterClient(MyCredentials.LastAuthenticatedCredentials);
var publishTweetParameters = new PublishTweetParameters(tweet);
if (fileBytes != null)
{
publishTweetParameters.MediaBinaries.Add(fileBytes);
}
var publishedTweet = await client.Tweets.PublishTweet(publishTweetParameters);
PostedTweets.Add(publishedTweet.Id, publishedTweet);
routeValueParameters.Add("id", publishedTweet.Id);
routeValueParameters.Add("actionPerformed", "Publish");
routeValueParameters.Add("success", true);
}
catch (Exception)
{
routeValueParameters.Add("success", false);
}
return(RedirectToAction("TweetPublished", routeValueParameters));
}
public static int EstimateTweetLength(string text)
{
var parameters = new PublishTweetParameters(text);
return(EstimateTweetLength(parameters));
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
while (!stoppingToken.IsCancellationRequested)
{
try
{
var lastTweetIdTask = _twitterLogService.GetLastTweetId();
var user = await _twitterClient.Users.GetUserAsync(_twitterBotSettings.BotUsername);
long sinceTweetId = await lastTweetIdTask;
var tweets = new List <ITweet>();
await foreach (var followerId in GetFollowersIds(user))
{
var getTimeLineParameters = new GetUserTimelineParameters(followerId);
if (sinceTweetId == 0)
{
getTimeLineParameters.PageSize = _twitterBotSettings.TimelineFirstLoadPageSize;
}
else
{
getTimeLineParameters.SinceId = sinceTweetId;
}
var timeLine = await _twitterClient.Timelines.GetUserTimelineAsync(getTimeLineParameters);
if (timeLine.Length == 0)
{
continue;
}
// Avoid Retweets.
tweets.AddRange(timeLine.Where(v => !v.Text.StartsWith("RT")));
}
foreach (var tweet in tweets)
{
var tweetText = StringUtils.RemoveHashtags(StringUtils.RemoveMentions(tweet.Text));
var correctionsResult = await _grammarService.GetCorrections(tweetText);
if (correctionsResult.HasCorrections)
{
var messageBuilder = new StringBuilder();
var mentionedUsers = tweet.UserMentions.Select(v => v.ToString()).Join(" "); // Other users mentioned in the tweet
messageBuilder.Append($"@{tweet.CreatedBy.ScreenName} {mentionedUsers}");
foreach (var correction in correctionsResult.Corrections)
{
// Only suggest the first possible replacement for now
messageBuilder.AppendLine($"*{correction.PossibleReplacements.First()} [{correction.Message}]");
}
var correctionString = messageBuilder.ToString();
_logger.LogInformation($"Sending reply to: {tweet.CreatedBy.ScreenName}");
var publishTweetParameters = new PublishTweetParameters(correctionString)
{
InReplyToTweetId = tweet.Id,
};
var replyTweet = await _twitterClient.Tweets.PublishTweetAsync(publishTweetParameters);
if (replyTweet != null)
{
_logger.LogInformation("Reply sent successfuly");
await _twitterLogService.LogReply(tweet.Id, replyTweet.Id);
}
await Task.Delay(_twitterBotSettings.PublishTweetDelayMilliseconds);
}
}
if (tweets.Any())
{
var lastTweet = tweets.OrderByDescending(v => v.Id).First();
// Save last Tweet Id
await _twitterLogService.LogTweet(lastTweet.Id);
}
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
}
await Task.Delay(_twitterBotSettings.HostedServiceIntervalMilliseconds);
}
}
public ITweet PublishTweet(string text, IPublishTweetOptionalParameters optionalParameters = null)
{
var parameters = new PublishTweetParameters(text, optionalParameters);
var tweetDTO = InternalPublishTweet(parameters);
return _tweetFactory.GenerateTweetFromDTO(tweetDTO);
}
public string PublishTweet(string text, IPublishTweetOptionalParameters optionalParameters = null)
{
// The exceptions have to be raised before the QueryGenerator as
// We do not want to wait for the media to be uploaded to throw the
// Exception. And The logic of uploading the media should live in
// the TweetController
var publishParameter = new PublishTweetParameters(text, optionalParameters);
_tweetQueryValidator.ThrowIfTweetCannotBePublished(publishParameter);
_tweetController.UploadMedias(publishParameter);
var query = _tweetQueryGenerator.GetPublishTweetQuery(publishParameter);
return _twitterAccessor.ExecutePOSTQueryReturningJson(query);
}
