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); }