private void AddFiltersStream(TwitterFilterOptions filteredOptions)
{
var user = User.GetUserFromScreenName(filteredOptions.FollowUserName);
_stream.AddFollow(user);
_stream.AddTrack(filteredOptions.Track);
}
private void CheckTwitterFollows()
{
if (_twitterStream == null)
{
return;
}
foreach (var user in _config.TwitterUpdates.TwitterUsers)
{
var userId = Convert.ToInt64(user);
if (_twitterStream.ContainsFollow(userId))
{
continue;
}
#pragma warning disable RECS0165
_twitterStream.AddFollow(userId, async x =>
#pragma warning restore RECS0165
{
if (userId != x.CreatedBy.Id)
{
return;
}
//if (x.IsRetweet) return;
await SendTwitterNotification(x.CreatedBy.Id, x.Url);
});
}
}
private static void InitializeStream()
{
stream = Stream.CreateFilteredStream();
stream.AddFollow(user);
stream.StreamStopped += StreamStopped;
stream.StreamStarted += StreamStarted;
stream.MatchingTweetReceived += MatchingTweetReceived;
}
public override void SetupEvent()
{
TwitterConnector twitterConnector = this.InParameters["twitter"].GetValue() as TwitterConnector;
this.stream = twitterConnector.Client.Streams.CreateFilteredStream();
stream.MatchingTweetReceived += Stream_MatchingTweetReceived;
var twitterUser = twitterConnector.Client.Users.GetUserAsync(this.InParameters["user"].GetValue().ToString());
twitterUser.Wait();
stream.AddFollow(twitterUser.Result);
stream.StartMatchingAllConditionsAsync();
}
private void StartTwitterStream()
{
TwitterStream = Tweetinvi.Stream.CreateFilteredStream();
TwitterStream.MatchingTweetReceived += OnTweetReceived;
TwitterStream.StallWarnings = true;
TwitterStream.WarningFallingBehindDetected += (sender, args) =>
{
Log.WriteWarn("Twitter", $"Stream falling behind: {args.WarningMessage.PercentFull} {args.WarningMessage.Code} {args.WarningMessage.Message}");
};
TwitterStream.StreamStopped += (sender, args) =>
{
var ex = args.Exception;
var twitterDisconnectMessage = args.DisconnectMessage;
if (ex != null)
{
Log.WriteError("Twitter", ex.ToString());
}
if (twitterDisconnectMessage != null)
{
Log.WriteError("Twitter", $"Stream stopped: {twitterDisconnectMessage.Code} {twitterDisconnectMessage.Reason}");
}
TwitterStream.StopStream();
Task.Factory.StartNew(() =>
{
Thread.Sleep(5000);
TwitterStream.StartStreamMatchingAnyConditionAsync();
});
};
var twitterUsers = Tweetinvi.User.GetUsersFromScreenNames(Config.Twitter.AccountsToFollow.Keys);
foreach (var user in twitterUsers)
{
var channels = Config.Twitter.AccountsToFollow.First(u => u.Key.Equals(user.ScreenName, StringComparison.InvariantCultureIgnoreCase));
Log.WriteInfo("Twitter", $"Following @{user.ScreenName}");
TwitterToChannels.Add(user.Id, channels.Value);
TwitterStream.AddFollow(user);
}
TwitterStream.StartStreamMatchingAnyConditionAsync();
}
public TtsBot(ILogger <TtsBot> logger, Option option, AdminAccess.AdminAccess.AdminAccessClient grpcClient, DataStore store)
{
_option = option ?? throw new ArgumentNullException(nameof(option));
_grpcClient = grpcClient ?? throw new ArgumentNullException(nameof(grpcClient));
_store = store ?? throw new ArgumentNullException(nameof(store));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_tweetIdRegex = new Regex(@"\/(?<tweetId>\d+)");
if (option.GoogleUseEnvironmentVariable)
{
_ttsClient = TextToSpeechClient.Create();
}
else
{
if (string.IsNullOrWhiteSpace(_option.GoogleApplicationCredentialsPath))
{
throw new ArgumentNullException(nameof(_option.GoogleApplicationCredentialsPath), "Credential path cannot be empty if not using Enviornment Variable \"GOOGLE_APPLICATION_CREDENTIALS\"");
}
TextToSpeechClientBuilder builder = new TextToSpeechClientBuilder();
builder.CredentialsPath = _option.GoogleApplicationCredentialsPath;
_ttsClient = builder.Build();
}
_discord = new DiscordSocketClient();
_discord.Log += obj =>
{
_logger.LogDebug("{0}", obj);
return(Task.CompletedTask);
};
_userCredentials = Auth.CreateCredentials(option.TwitterConsumerKey,
option.TwitterConsumerSecret,
option.TwitterUserAccessToken,
option.TwitterUserAccessSecret);
Auth.SetCredentials(_userCredentials);
_stream = TwitterStream.CreateFilteredStream(_userCredentials, TweetMode.Extended);
_stream.MatchingTweetReceived += OnMatchingTweetReceived;
foreach (var user in _store.Users)
{
_stream.AddFollow(user.Id);
}
_store.UsersChanged += OnUserAddedToDataStore;
}
private void OnUserAddedToDataStore(object sender, UserChangedEventArgs args)
{
_stream.PauseStream();
if (args.NewUser != null)
{
_stream.AddFollow(args.NewUser.Id);
}
if (args.OldUser != null)
{
_stream.RemoveFollow(args.OldUser.Id);
}
_stream.ResumeStream();
}
public async Task StartAsync(CancellationToken cancellationToken)
{
var consumerKey = Environment.GetEnvironmentVariable("TwitterConsumerKey");
var consumerSecret = Environment.GetEnvironmentVariable("TwitterConsumerSecret");
var accessKey = Environment.GetEnvironmentVariable("TwitterAccessKey");
var accessSecret = Environment.GetEnvironmentVariable("TwitterAccessSecret");
var userClient = new TwitterClient(consumerKey, consumerSecret, accessKey, accessSecret);
_filteredStream = userClient.Streams.CreateFilteredStream();
if (!string.IsNullOrEmpty(_attribute.Filter))
{
_filteredStream.AddTrack(_attribute.Filter);
}
if (!string.IsNullOrWhiteSpace(_attribute.User))
{
var user = await userClient.Users.GetUserAsync(_attribute.User);
_filteredStream.AddFollow(user);
}
_filteredStream.MatchingTweetReceived += async(obj, tweetEvent) =>
{
var triggerData = new TriggeredFunctionData
{
TriggerValue = tweetEvent
};
await Executor.TryExecuteAsync(triggerData, CancellationToken.None);
};
_filteredStream.DisconnectMessageReceived += (obj, disconnectEvent) =>
{
_filteredStream.Stop();
};
await _filteredStream.StartMatchingAllConditionsAsync();
}
public static async Task RegisterFilteredStreamEventsAsync(string[] users, string[] trackKeywords)
{
if (users == null)
{
log.Fatal("No Users Are Being Followed. Server is useless.");
return;
}
try
{
stream = Stream.CreateFilteredStream();
foreach (string userName in users)
{
IUserIdentifier myUser = Tweetinvi.User.GetUserFromScreenName(userName);
stream.AddFollow(myUser);
}
if (trackKeywords != null)
{
foreach (string keyword in trackKeywords)
{
stream.AddTrack(keyword);
}
}
stream.MatchingTweetReceived += StreamEventCallbackManager.FilteredStream_MatchingTweetReceived;
stream.StreamStopped += StreamEventCallbackManager.Stream_Stopped;
stream.DisconnectMessageReceived += StreamEventCallbackManager.Stream_Disconnected;
stream.StreamPaused += StreamEventCallbackManager.Stream_Paused;
stream.StreamResumed += StreamEventCallbackManager.Stream_Resumed;
await stream.StartStreamMatchingAllConditionsAsync();
log.Info("Now Listening To Stream Events.");
}
catch (Exception e)
{
log.Fatal("FAILED TO REGISTER TO STREAM EVENTS!", e);
}
}
public void CreateCommands()
{
var CService = _client.GetService <CommandService>();
IFilteredStream FilteredStream = Tweetinvi.Stream.CreateFilteredStream();
ISampleStream SampleStream = Tweetinvi.Stream.CreateSampleStream();
CService.CreateCommand("StreamState")
.Description("Gets the states of the streams")
.Do(async(e) =>
{
await e.Channel.SendMessage("```Sample Stream: " + SampleStream.StreamState + Environment.NewLine + "Filtered Stream: " + FilteredStream.StreamState + "```");
});
CService.CreateCommand("PurgeStreams")
.Alias("Kill", "Stop", "PS")
.Description("Hopefully stops the stream")
.Do(async(e) =>
{
FilteredStream.StopStream();
SampleStream.StopStream();
FilteredStream.ClearTracks();
await e.Channel.SendMessage("```Sample Stream: " + SampleStream.StreamState + Environment.NewLine + "Filtered Stream: " + FilteredStream.StreamState + "```");
});
CService.CreateCommand("StopSampleStream")
.Description("Stops all sample streams")
.Do(async(e) =>
{
SampleStream.StopStream();
await e.Channel.SendMessage("```Sample Stream: " + SampleStream.StreamState + Environment.NewLine + "Filtered Stream: " + FilteredStream.StreamState + "```");
});
CService.CreateCommand("StopFilteredStream")
.Description("Stops all Filtered streams")
.Do(async(e) =>
{
FilteredStream.StopStream();
await e.Channel.SendMessage("```Sample Stream: " + SampleStream.StreamState + Environment.NewLine + "Filtered Stream: " + FilteredStream.StreamState + "```");
});
CService.CreateCommand("Track")
.Description("Tracks a twitter User Either from their ID or Handle")
.Parameter("User", ParameterType.Unparsed)
.Description("Tracks a Twitter User")
.Do(async(e) =>
{
if (Regex.IsMatch(e.GetArg("User"), @"-?\d+(\.\d+)?"))
{
long User = Convert.ToInt64(e.GetArg("User"));
IUser Target = Tweetinvi.User.GetUserFromId(Convert.ToInt64(e.GetArg("User")));
await e.Channel.SendMessage("Tracking " + Tweetinvi.User.GetUserFromId(Convert.ToInt64(e.GetArg("User"))));
FilteredStream.AddFollow(User);
FilteredStream.MatchingTweetReceived += (sender, args) =>
{
e.Channel.SendMessage(Target + " " + args.Tweet);
};
FilteredStream.StreamStopped += (sender, args) =>
{
var Exception = args.Exception;
var DisconnectMessage = args.DisconnectMessage;
e.Channel.SendMessage("Filtered stream ended exception: " + Exception + " Disconnect message: " + DisconnectMessage);
};
await FilteredStream.StartStreamMatchingAllConditionsAsync();
}
else
{
var Target = Tweetinvi.User.GetUserFromScreenName(e.GetArg("User"));
await e.Channel.SendMessage("Tracking " + Tweetinvi.User.GetUserFromScreenName(e.GetArg("User")));
FilteredStream.AddFollow(Target);
FilteredStream.MatchingTweetReceived += (sender, args) =>
{
Console.WriteLine("Found Tweet");
e.Channel.SendMessage(e.GetArg("User") + " Tweeted " + args.Tweet);
};
await FilteredStream.StartStreamMatchingAllConditionsAsync();
}
});
CService.CreateCommand("Spam")
.Alias("Havoc", "Anton", "Cancer")
.Description("Initializes a socalled sample stream which returns 1% of all public tweets Discord will not show them all because of RateLimits.")
.Do(async(e) =>
{
if (e.User.ServerPermissions.ManageServer == true)
{
SampleStream.TweetReceived += (sender, args) =>
{
e.Channel.SendMessage(args.Tweet.Text.ToString());
};
await SampleStream.StartStreamAsync();
}
else
{
await e.Channel.SendMessage("ERROR most likely you do not have sufficient permissions");
}
});
CService.CreateCommand("Sample")
.Description("Initializes a socalled sample stream but instead of 1% its specified with an amount of random tweets, Neat!")
.Parameter("Tweets", ParameterType.Unparsed)
.Do(async(e) =>
{
if (Regex.IsMatch(e.GetArg("Tweets"), @"-?\d+(\.\d+)?"))
{
int Tweets = Convert.ToInt32(e.GetArg("Tweets"));
await e.Channel.SendMessage("Transmitting " + e.GetArg("Tweets") + " Tweets");
int i = 0;
SampleStream.TweetReceived += (sender, args) =>
{
i++;
if (i < Tweets)
{
e.Channel.SendMessage(args.Tweet.Text.ToString());
}
else
{
SampleStream.StopStream();
}
};
FilteredStream.StreamStopped += (sender, args) =>
{
var Exception = args.Exception;
var DisconnectMessage = args.DisconnectMessage;
e.Channel.SendMessage("Filtered stream ended exception: " + Exception + " Disconnect message: " + DisconnectMessage);
};
await SampleStream.StartStreamAsync();
}
else
{
await e.Channel.SendMessage("Error Invalid input");
}
});
}
public void TweetTask(string text, bool displayMsg = true)
{
RateLimit.RateLimitTrackerMode = RateLimitTrackerMode.TrackAndAwait; //to avoid ratelimits, let Tweetinvi handle it
var embed = new EmbedBuilder();
if (stream == null)
{
stream = Stream.CreateFilteredStream(); //create a stream for the live feed
}
foreach (var feed in twitterFeeds)
{
stream.AddFollow(User.GetUserFromScreenName(feed.twitterUser)); //set the stream to follow said user(s)
}
stream.MatchingTweetReceived += async(sender, args) =>
{
var tweet = args.Tweet;
foreach (var feed in twitterFeeds)
{
if (tweet.CreatedBy.ScreenName == feed.twitterUser) //if the twitter screen name matches a saved screen name...
{
embed = new EmbedBuilder();
embed.WithAuthor($"{tweet.CreatedBy.Name} (@{tweet.CreatedBy.ScreenName})", tweet.CreatedBy.ProfileImageUrl, tweet.Url);
embed.WithDescription(tweet.Text);
embed.WithColor(0, 172, 237); //Twitter blue
if (tweet.Media.Count > 0)
{
embed.WithImageUrl(tweet.Media[0].MediaURL);
}
foreach (var channel in feed.channels) //post the embedded tweet in every channel
{
await channel.SendMessageAsync("", false, embed.Build());
}
break;
}
}
};
stream.StreamStopped += (sender, args) =>
{
if (args.Exception != null)
{
Console.WriteLine(args.Exception);
}
};
var MainThread = new Thread(() => stream.StartStreamMatchingAnyConditionAsync());
MainThread.Start();
MainThread = new Thread(async() =>
{
if (!String.IsNullOrWhiteSpace(text) && displayMsg)
{
var msg = await ReplyAsync($"`Live feed is now hooked into @{text}.`");
await Task.Delay(2000);
await msg.DeleteAsync();
}
else if (!displayMsg)
{
var msg = await ReplyAsync($"`The live feed of @{text} has been removed.`");
await Task.Delay(2000);
await msg.DeleteAsync();
}
await Context.Client.SetGameAsync($"{twitterFeeds.Count} user's Twitter feed", null, ActivityType.Listening);
while (true)
{
Thread.Sleep(2000);
if (!running)
{
stream.StopStream();
stream.ClearFollows();
await Context.Client.SetGameAsync(null);
break;
}
}
});
MainThread.Start();
MainThread.IsBackground = true;
}
public void AddFollow(IUser userToFollow, Action <ITweet> actionOnReceived)
{
stream.AddFollow(userToFollow, actionOnReceived);
}
private void TweetThread()
{
_backtraceClient?.Send($"{_breadcrumbName} started");
_log.Info("Tweet thread started!");
FilteredStream = _twitterClient.Streams.CreateFilteredStream();
FilteredStream.FilterLevel = StreamFilterLevel.None;
FilteredStream.StallWarnings = true;
foreach (var stream in _config.Streams)
{
FilteredStream.AddFollow(stream.TwitterUserId);
_log.Info($"Added {stream.TwitterUserId} to tracking");
}
_backtraceClient?.Send("Added configured IDs to stream");
FilteredStream.MatchingTweetReceived += (sender, args) =>
{
ITweet tweet = args.Tweet;
_log.Info($"Found tweet from {tweet.CreatedBy.ScreenName}");
TwitterStreamConfigModel.Stream stream =
_config.Streams.Find(s => s.TwitterUserId == tweet.CreatedBy.Id);
if (stream == null)
{
return;
}
Dictionary <string, string> data =
new Dictionary <string, string>
{
{ "Twitter ID", tweet.CreatedBy.IdStr },
{ "Tweet ID", tweet.IdStr },
{ "Tweet Body", tweet.FullText },
{ "Destination channels", string.Join(", ", stream.Channels) }
};
_backtraceClient?.Send($"Found matching Tweet, from {tweet.CreatedBy.Name}");
if (stream.IgnoreRetweets && tweet.IsRetweet)
{
_log.Info(
$"Ignoring tweet {tweet.IdStr} as IgnoreRetweets is {stream.IgnoreRetweets} and IsRetweet is {tweet.IsRetweet}");
return;
}
if (stream.IgnoreReplies && tweet.InReplyToUserId != null)
{
_log.Info(
$"Ignoring tweet {tweet.IdStr} as IgnoreReplies is {stream.IgnoreReplies} and InReplyToUserId is not null (it is {tweet.InReplyToUserId})");
return;
}
if (tweet.IsRetweet)
{
if (stream.RetweetsToIgnoreByUserId.Contains(tweet.RetweetedTweet.CreatedBy.Id))
{
_log.Info($"Ignoring tweet {tweet.IdStr} as author has been ignored");
return;
}
}
foreach (string channel in stream.Channels)
{
if (!_ircClient.JoinedChannels.Contains(channel))
{
continue;
}
_log.Info($"Sending tweet from {tweet.CreatedBy.Name} to {channel}");
if (_ircClient.IsConnected)
{
if (tweet.IsRetweet)
{
if (tweet.CreatedBy.Name == tweet.CreatedBy.ScreenName)
{
_ircClient.SendMessage(SendType.Message, channel,
$"{IrcConstants.IrcBold}@{tweet.CreatedBy.ScreenName}:{IrcConstants.IrcNormal} RT @{tweet.RetweetedTweet.CreatedBy.ScreenName} {WebUtility.HtmlDecode(tweet.RetweetedTweet.FullText.ReplaceNonPrintableCharacters(' ').ReplaceNewlines("⏎"))} - {tweet.Url}");
return;
}
_ircClient.SendMessage(SendType.Message, channel,
$"{IrcConstants.IrcBold}{tweet.CreatedBy.Name} (@{tweet.CreatedBy.ScreenName}):{IrcConstants.IrcNormal} RT @{tweet.RetweetedTweet.CreatedBy.ScreenName} {WebUtility.HtmlDecode(tweet.RetweetedTweet.FullText.ReplaceNonPrintableCharacters(' ').ReplaceNewlines("⏎"))} - {tweet.Url}");
return;
}
if (tweet.CreatedBy.Name == tweet.CreatedBy.ScreenName)
{
_ircClient.SendMessage(SendType.Message, channel,
$"{IrcConstants.IrcBold}@{tweet.CreatedBy.ScreenName}:{IrcConstants.IrcNormal} {WebUtility.HtmlDecode(tweet.FullText.ReplaceNonPrintableCharacters(' ').ReplaceNewlines("⏎"))} - {tweet.Url}");
return;
}
_ircClient.SendMessage(SendType.Message, channel,
$"{IrcConstants.IrcBold}{tweet.CreatedBy.Name} (@{tweet.CreatedBy.ScreenName}):{IrcConstants.IrcNormal} {WebUtility.HtmlDecode(tweet.FullText.ReplaceNonPrintableCharacters(' ').ReplaceNewlines("⏎"))} - {tweet.Url}");
return;
}
_log.Error("Tried to send message to channel but IRC bot is not connected");
}
};
FilteredStream.StreamStopped += (sender, args) =>
{
_log.Error("Twitter stream disconnected with following reason");
_log.Error(args.DisconnectMessage?.Reason);
_backtraceClient?.Send(args.Exception);
if (args.DisconnectMessage != null) // If socket closed for "reasons" this will be null
{
_log.Error(
$"Twitter disconnect message was: ({args.DisconnectMessage.Code}) {args.DisconnectMessage.Reason}");
}
};
FilteredStream.WarningFallingBehindDetected += (sender, args) =>
{
_log.Info($"Twitter stream is falling behind. Warning from Twitter: {args.WarningMessage.Message}");
_log.Info($"Twitter queue is {args.WarningMessage.PercentFull}% full");
_backtraceClient?.Send($"Twitter stream falling behind, queue {args.WarningMessage.PercentFull}% full");
};
while (true)
{
try
{
FilteredStream.StartMatchingAnyConditionAsync().Wait();
Thread.Sleep(5000);
}
catch (Exception e)
{
_log.Error(e);
}
}
}
public static void CreateCommands()
{
var CService = _client.GetService <CommandService>();
ISampleStream SampleStream = Tweetinvi.Stream.CreateSampleStream();
IFilteredStream FilteredStream = Tweetinvi.Stream.CreateFilteredStream();
CService.CreateCommand("State")
.Alias("StreamState", "SS")
.Description("Displays whether the streams are running or not")
.Do(async(e) =>
{
await e.Channel.SendMessage($"Filtered Stream: {FilteredStream.StreamState} {Environment.NewLine}Sample Stream: {SampleStream.StreamState}");
});
CService.CreateCommand("PurgeStreams")
.Alias("PS", "Purge")
.Description("Purges all running streams")
.Do(async(e) =>
{
SampleStream.StopStream();
FilteredStream.StopStream();
FilteredStream.ClearTracks();
await e.Channel.SendMessage($"```Sample Stream: {SampleStream.StreamState} {Environment.NewLine}Filtered Stream: {FilteredStream.StreamState}```");
});
CService.CreateCommand("Sample")
.Description("Initializes a socalled sample stream but instead of 1% its specified with an amount of random tweets, Neat!")
.Parameter("Tweets", ParameterType.Unparsed)
.Do(async(e) =>
{
if (Regex.IsMatch(e.GetArg("Tweets"), @"-?\d+(\.\d+)?"))
{
int Tweets = Convert.ToInt32(e.GetArg("Tweets"));
await e.Channel.SendMessage("Transmitting " + e.GetArg("Tweets") + " Tweets");
Console.WriteLine(Tweetinvi.User.GetAuthenticatedUser());
int i = 0;
SampleStream.TweetReceived += (sender, args) =>
{
if (i < Tweets)
{
e.Channel.SendMessage(args.Tweet.Text.ToString());
i++;
}
else
{
SampleStream.StopStream();
}
};
SampleStream.StreamStopped += (sender, args) =>
{
var Exception = args.Exception;
var DisconnectMessage = args.DisconnectMessage;
e.Channel.SendMessage($"```Stream ended { Environment.NewLine }Exception: { Exception } { Environment.NewLine }Disconnect message: { DisconnectMessage }```");
};
await SampleStream.StartStreamAsync();
}
else
{
await e.Channel.SendMessage("Error Invalid input");
}
});
CService.CreateCommand("Track")
.Description("Tracks a twitter User Either from their ID or Handle")
.Parameter("User", ParameterType.Unparsed)
.Description("Tracks a Twitter User")
.Do(async(e) =>
{
if (Regex.IsMatch(e.GetArg("User"), @"-?\d+(\.\d+)?"))
{
long User = Convert.ToInt64(e.GetArg("User"));
IUser Target = Tweetinvi.User.GetUserFromId(Convert.ToInt64(e.GetArg("User")));
await e.Channel.SendMessage($"Tracking { Tweetinvi.User.GetUserFromId(Convert.ToInt64(e.GetArg("User"))) }");
FilteredStream.AddFollow(User);
FilteredStream.MatchingTweetReceived += (sender, args) =>
{
e.Channel.SendMessage(Target + " " + args.Tweet);
};
FilteredStream.StreamStopped += (sender, args) =>
{
e.Channel.SendMessage("Filtered Stream Ended");
};
await FilteredStream.StartStreamMatchingAllConditionsAsync();
}
else
{
var Target = Tweetinvi.User.GetUserFromScreenName(e.GetArg("User"));
await e.Channel.SendMessage($"Tracking { Tweetinvi.User.GetUserFromScreenName(e.GetArg("User")) }");
FilteredStream.AddFollow(Target);
FilteredStream.MatchingTweetReceived += (sender, args) =>
{
Console.WriteLine("Found Tweet");
e.Channel.SendMessage($"{ e.GetArg("User") } Tweeted { args.Tweet }");
};
await FilteredStream.StartStreamMatchingAllConditionsAsync();
}
});
}
public void StartStream()
{
Tweetinvi.ExceptionHandler.SwallowWebExceptions = false;
var credentials = Tweetinvi.Auth.SetUserCredentials(
TwitterAppCredentials.ConsumerKey,
TwitterAppCredentials.ConsumerSecret,
TwitterAppCredentials.AccessToken,
TwitterAppCredentials.AccessSecret
);
var user = Tweetinvi.User.GetUserFromScreenName("AndrewYang");
_filteredStream = Tweetinvi.Stream.CreateFilteredStream();
_filteredStream.FilterLevel = Tweetinvi.Streaming.Parameters.StreamFilterLevel.None;
_filteredStream.TweetMode = Tweetinvi.TweetMode.Extended;
//_filteredStream.AddLocation(new Location(30.6266, 81.4609, 30.6319, 81.6065));
_filteredStream.AddFollow(user.Id);
_filteredStream.AddTrack("YangGang");
_filteredStream.AddTrack("NevadaCaucuses");
_filteredStream.AddTrack("StillVotingYang");
_filteredStream.AddTrack("NevadaForYang");
//stream.AddTrack("SecureTheBag");
//stream.AddTrack("YangMediaBlackout");
//stream.AddTrack("YangMediaShoutout");
//stream.AddTrack("YangWillWin");
//stream.AddTrack("YangOrBust");
//stream.AddTrack("YangBeatsTrump");
//stream.AddTrack("NewHampshireForYang");
//stream.AddTrack("AmericaNeedsYang");
//stream.AddTrack("LetYangSpeak");
//stream.AddTrack("VoteYang");
_filteredStream.MatchingTweetReceived += (sender, args) =>
{
try
{
ITweet fullTweet = null;
ITweet childTweet = null;
var tweet = args.Tweet;
if (tweet.IsRetweet)
{
return;
}
TwitterUser savedUser;
using (var db = new TwitterSearchModel())
{
savedUser = db.TwitterUsers.Where(u => u.TwitterUserID == tweet.CreatedBy.IdStr).FirstOrDefault();
}
if (savedUser == null)
{
var user = Tweetinvi.User.GetUserFromId(tweet.CreatedBy.Id);
var userJson = Tweetinvi.JsonSerializer.ToJson(user.UserDTO);
Console.WriteLine($"New User: {userJson}");
using (var db = new TwitterSearchModel())
{
db.TwitterUsers.Add(new TwitterUser
{
TwitterUserID = user.IdStr,
TwitterUserJson = userJson
});
db.SaveChanges();
}
}
TweetRecord savedTweet;
using (var db = new TwitterSearchModel())
{
savedTweet = db.TweetRecords.Where(t => t.TweetID == tweet.IdStr).FirstOrDefault();
}
if (savedTweet == null)
{
fullTweet = Tweetinvi.Tweet.GetTweet(tweet.Id);
//var voteYang = Tweetinvi.Timeline.GetUserTimeline(.GetExistingList()
var tweetJson = Tweetinvi.JsonSerializer.ToJson(fullTweet.TweetDTO);
using (var db = new TwitterSearchModel())
{
db.TweetRecords.Add(new TweetRecord
{
TweetID = tweet.IdStr,
TweetJson = tweetJson
});
db.SaveChanges();
}
Console.WriteLine($"User: {fullTweet.CreatedBy.Name}");
Console.WriteLine($"Tweet: {fullTweet.FullText ?? fullTweet.Text}");
Console.WriteLine($"{fullTweet.Url}");
Console.WriteLine();
}
//tweetPostQueue.Enqueue(tweet)
//var fbPostResult = PostToFacebook(tweet).Result;
string childTweetIDStr = tweet.InReplyToStatusIdStr ?? tweet.QuotedStatusIdStr;
if (childTweetIDStr != null)
{
long childTweetID = tweet.InReplyToStatusId ?? tweet.QuotedStatusId ?? 0;
childTweet = Tweetinvi.Tweet.GetTweet(childTweetID);
TweetRecord savedChildTweet;
using (var db = new TwitterSearchModel())
{
savedChildTweet = db.TweetRecords.Where(t => t.TweetID == childTweetIDStr).FirstOrDefault();
}
if (savedChildTweet == null)
{
if (childTweetID != 0)
{
if (childTweet != null)
{
using (var db = new TwitterSearchModel())
{
db.TweetRecords.Add(
new TweetRecord
{
TweetID = childTweetIDStr,
TweetJson = Tweetinvi.JsonSerializer.ToJson(childTweet.TweetDTO)
});
db.SaveChanges();
}
}
}
}
}
if (fullTweet != null && childTweet == null)
{
_tweetHub.Clients.All.SendAsync("ReceiveTweet", fullTweet.TweetDTO.ToJson(), null);
}
if (fullTweet != null && childTweet != null)
{
_tweetHub.Clients.All.SendAsync("ReceiveTweet", fullTweet.TweetDTO.ToJson(), childTweet.TweetDTO.ToJson());
}
}
catch (Exception e)
{
Console.WriteLine($"ERROR: { e.Message}");
}
finally
{
}
};
_filteredStream.StartStreamMatchingAnyCondition();
}
