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}");
        }
    }
Exemplo n.º 2
0
        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);
            }
        }