private async void OnTweetReceived(object sender, MatchedTweetReceivedEventArgs matchedTweetReceivedEventArgs)
{
// Skip replies
if (matchedTweetReceivedEventArgs.Tweet.InReplyToUserId != null && !TwitterToChannels.ContainsKey(matchedTweetReceivedEventArgs.Tweet.InReplyToUserId.GetValueOrDefault()))
{
return;
}
Log.WriteDebug("Twitter", $"Streamed {matchedTweetReceivedEventArgs.Tweet.Url}: {matchedTweetReceivedEventArgs.Tweet.FullText}");
if (!TwitterToChannels.ContainsKey(matchedTweetReceivedEventArgs.Tweet.CreatedBy.Id))
{
return;
}
// TODO: Streaming api does not seem to return extended tweets
var tweet = await TweetAsync.GetTweet(matchedTweetReceivedEventArgs.Tweet.Id);
if (tweet?.FullText == null)
{
return;
}
var text = $"{Color.BLUE}@{tweet.CreatedBy.ScreenName}{Color.NORMAL} tweeted {tweet.CreatedAt.ToRelativeString()}: {FormatTweet(tweet)} -{Color.DARKBLUE} {tweet.Url}";
foreach (var channel in TwitterToChannels[tweet.CreatedBy.Id])
{
Bootstrap.Client.Client.Message(channel, text);
}
}
public MatchedTweetReceivedEventArgs GetMatchingTweetEventArgsAndRaiseMatchingElements(ITweet tweet, string json, MatchOn matchOn)
{
var result = new MatchedTweetReceivedEventArgs(tweet, json);
var trackMatcherConfig = new FilteredStreamMatcherConfig <string>(matchOn);
var locationMatcherConfig = new FilteredStreamMatcherConfig <ILocation>(matchOn);
var followersMatcherConfig = new FilteredStreamMatcherConfig <long>(matchOn);
UpdateMatchesBasedOnTweetText(tweet, trackMatcherConfig, result);
UpdateMatchesBasedOnUrlEntities(tweet, trackMatcherConfig, result);
UpdateMatchesBasedOnHashTagEntities(tweet, trackMatcherConfig, result);
UpdateMatchesBasedOnUserMentions(tweet, trackMatcherConfig, result);
UpdateMatchesBasedOnSymbols(tweet, trackMatcherConfig, result);
UpdateMatchesBasedOnTweetLocation(tweet, locationMatcherConfig, result);
UpdateMatchesBasedOnTweetCreator(tweet, followersMatcherConfig, result);
UpdateMatchesBasedOnTweetInReplyToUser(tweet, followersMatcherConfig, result);
result.MatchingTracks = trackMatcherConfig.TweetMatchingTrackAndActions.Select(x => x.Key).ToArray();
result.MatchingLocations = locationMatcherConfig.TweetMatchingTrackAndActions.Select(x => x.Key).ToArray();
result.MatchingFollowers = followersMatcherConfig.TweetMatchingTrackAndActions.Select(x => x.Key).ToArray();
result.RetweetMatchingTracks = trackMatcherConfig.RetweetMatchingTrackAndActions.Select(x => x.Key).ToArray();
result.RetweetMatchingLocations = locationMatcherConfig.RetweetMatchingTrackAndActions.Select(x => x.Key).ToArray();
result.RetweetMatchingFollowers = followersMatcherConfig.RetweetMatchingTrackAndActions.Select(x => x.Key).ToArray();
result.QuotedTweetMatchingTracks = trackMatcherConfig.QuotedTweetMatchingTrackAndActions.Select(x => x.Key).ToArray();
result.QuotedTweetMatchingLocations = locationMatcherConfig.QuotedTweetMatchingTrackAndActions.Select(x => x.Key).ToArray();
result.QuotedTweetMatchingFollowers = followersMatcherConfig.QuotedTweetMatchingTrackAndActions.Select(x => x.Key).ToArray();
CallMultipleActions(tweet, trackMatcherConfig.GetAllMatchingTracks().Select(x => x.Value));
CallMultipleActions(tweet, locationMatcherConfig.GetAllMatchingTracks().Select(x => x.Value));
CallMultipleActions(tweet, followersMatcherConfig.GetAllMatchingTracks().Select(x => x.Value));
return(result);
}
/*private functions*/
//Function responsible for handling the match to a tweet from the stream
void handleMatchingTweet(object sender, MatchedTweetReceivedEventArgs args)
{
Matches++;
foreach (var media in args.Tweet.Media)
{
//If the media is a photo
//right now the only mediatype twitter gives us, but can change in the future
if (media.MediaType == "photo")
{
var url = media.MediaURL ?? media.MediaURLHttps;
//Filename is taken from the last section of the url
var fileName = url.Substring(url.LastIndexOf("/") + 1);
//download picture to image
var image = GetDataByHttp(url);
//TODO: Find male and female faces in image and generate a Gender[]
//Store Metadata for the processed picture(Todo: pass Gender[] instead of null
PictureMetaData meta = new PictureMetaData(DateTime.Now, null);
PictureMetaDataList.Add(meta);
//save the picture in the pictureQueue(treadsafe)
EnqueuePicture(new PictureData(image, fileName, meta));
DownloadedPictures++;
}
}
}
private void UpdateMatchesBasedOnHashTagEntities(ITweet tweet, MatchOn matchOn, Dictionary <string, Action <ITweet> > matchingTrackAndActions,
MatchedTweetReceivedEventArgs matchingTracksEventArgs, Dictionary <string, Action <ITweet> > matchingQuotedTrackAndActions)
{
if (matchOn.HasFlag(MatchOn.Everything) ||
matchOn.HasFlag(MatchOn.AllEntities) ||
matchOn.HasFlag(MatchOn.HashTagEntities))
{
var hashTags = tweet.Entities.Hashtags.Select(x => x.Text);
hashTags.ForEach(x =>
{
var tracksMatchingHashTag = _streamTrackManager.GetMatchingTracksAndActions(x);
tracksMatchingHashTag.ForEach(t => { matchingTrackAndActions.TryAdd(t.Item1, t.Item2); });
if (tracksMatchingHashTag.Count > 0)
{
matchingTracksEventArgs.MatchOn |= MatchOn.HashTagEntities;
}
});
if (tweet.QuotedTweet != null)
{
var quotedHashTags = tweet.QuotedTweet.Entities.Hashtags.Select(x => x.Text);
quotedHashTags.ForEach(x =>
{
var tracksMatchingHashTag = _streamTrackManager.GetMatchingTracksAndActions(x);
tracksMatchingHashTag.ForEach(t => { matchingQuotedTrackAndActions.TryAdd(t.Item1, t.Item2); });
if (tracksMatchingHashTag.Count > 0)
{
matchingTracksEventArgs.QuotedTweetMatchOn |= MatchOn.HashTagEntities;
}
});
}
}
}
private void OnMatchingTweetReceived(object sender, MatchedTweetReceivedEventArgs e)
{
Trace.WriteLine(string.Concat("Twitter | ", e.Tweet.Text));
twitterSender.SendMessage(e.Tweet);
twitterLike.SendMessage(e.Tweet);
twitterDislike.SendMessage(e.Tweet);
}
private static void Stream_TweetReceived(object sender, MatchedTweetReceivedEventArgs e)
{
if (e.Tweet.InReplyToStatusId == null)
{
return;
}
ITweet r1 = Tweetinvi.Tweet.GetTweet((long)e.Tweet.InReplyToStatusId);
if (r1 == null)
{
return;
}
Conversation c = new Conversation();
c.Tweets.Add(InviTweetToPTTweet(e.Tweet));
c.Tweets.Add(InviTweetToPTTweet(r1));
using (var model = new AnnotatorModel())
{
Console.WriteLine(r1.Text);
Console.WriteLine(e.Tweet.Text);
model.Tweets.Add(InviTweetToPTTweet(r1));
model.Tweets.Add(InviTweetToPTTweet(e.Tweet));
model.Conversations.Add(c);
model.SaveChanges();
}
}
private void UpdateMatchesBasedOnUserMentions(ITweet tweet, MatchOn matchOn, Dictionary <string, Action <ITweet> > matchingTrackAndActions,
MatchedTweetReceivedEventArgs matchingTracksEventArgs, Dictionary <string, Action <ITweet> > matchingQuotedTrackAndActions)
{
if (matchOn.HasFlag(MatchOn.Everything) ||
matchOn.HasFlag(MatchOn.AllEntities) ||
matchOn.HasFlag(MatchOn.UserMentionEntities))
{
var mentionsScreenName = tweet.Entities.UserMentions.Select(x => x.ScreenName);
mentionsScreenName.ForEach(x =>
{
var tracksMatchingMentionScreenName = _streamTrackManager.GetMatchingTracksAndActions(x);
tracksMatchingMentionScreenName.ForEach(t => { matchingTrackAndActions.TryAdd(t.Item1, t.Item2); });
if (tracksMatchingMentionScreenName.Count > 0)
{
matchingTracksEventArgs.MatchOn |= MatchOn.UserMentionEntities;
}
});
if (tweet.QuotedTweet != null)
{
var quotedMentionsScreenName = tweet.QuotedTweet.Entities.UserMentions.Select(x => x.ScreenName);
quotedMentionsScreenName.ForEach(x =>
{
var tracksMatchingMentionScreenName = _streamTrackManager.GetMatchingTracksAndActions(x);
tracksMatchingMentionScreenName.ForEach(t => { matchingQuotedTrackAndActions.TryAdd(t.Item1, t.Item2); });
if (tracksMatchingMentionScreenName.Count > 0)
{
matchingTracksEventArgs.QuotedTweetMatchOn |= MatchOn.UserMentionEntities;
}
});
}
}
}
private void UpdateMatchesBasedOnTweetCreator(ITweet tweet, MatchOn matchOn, Dictionary <long, Action <ITweet> > matchingFollowersAndActions,
MatchedTweetReceivedEventArgs matchingTracksEventArgs, Dictionary <long, Action <ITweet> > matchingQuotedFollowersAndActions)
{
if (matchOn.HasFlag(MatchOn.Everything) ||
matchOn.HasFlag(MatchOn.Follower))
{
var userId = tweet.CreatedBy?.Id;
Action <ITweet> actionToExecuteWhenMatchingFollower;
if (userId != null && _followingUserIds.TryGetValue(userId, out actionToExecuteWhenMatchingFollower))
{
matchingFollowersAndActions.TryAdd(userId.Value, actionToExecuteWhenMatchingFollower);
matchingTracksEventArgs.MatchOn |= MatchOn.Follower;
}
if (tweet.QuotedTweet != null)
{
var quotedTweetCreatorId = tweet.QuotedTweet.CreatedBy?.Id;
Action <ITweet> actionToExecuteWhenMatchingFollowerFromQuotedTweet;
if (quotedTweetCreatorId != null && _followingUserIds.TryGetValue(quotedTweetCreatorId, out actionToExecuteWhenMatchingFollowerFromQuotedTweet))
{
matchingQuotedFollowersAndActions.TryAdd(quotedTweetCreatorId.Value, actionToExecuteWhenMatchingFollowerFromQuotedTweet);
matchingTracksEventArgs.QuotedTweetMatchOn |= MatchOn.Follower;
}
}
}
}
public static void TweetRecieved(object sender, MatchedTweetReceivedEventArgs args)
{
if (args.Tweet == null)
{
return;
}
Console.WriteLine($"Tweet recieved {args.Tweet.FullText}");
var report = new FireReport()
{
TimeStamp = args.Tweet.CreatedAt,
FireSeverity = EFireSeverity.Unkown,
Description = args.Tweet.FullText
};
if (report.Description != null && (report.Description.ToLower().Contains("severe") || report.Description.ToLower().Contains("urgent")))
{
report.FireSeverity = EFireSeverity.LargerThan100LessThan500Meters;
}
if (args.Tweet.Place?.BoundingBox?.Coordinates != null)
{
report.BoundingBox = args.Tweet.Place.BoundingBox.Coordinates.Select(x => x.ToGeoCoordinate()).ToList();
report.Coordinates = new GeoCoordinate(args.Tweet.Place.BoundingBox.Coordinates.Average(x => x.Latitude), args.Tweet.Place.BoundingBox.Coordinates.Average(x => x.Longitude));
}
Console.WriteLine($"Trying to store tweet {JsonConvert.SerializeObject(report)}");
_serviceProvider.GetService <IFireReport>()?.AddReport(report);
}
private static Gof.Twitter.Tweet formatTweet(MatchedTweetReceivedEventArgs e)
{
var author = e.Tweet.RetweetedTweet != null ? e.Tweet.RetweetedTweet.CreatedBy : e.Tweet.CreatedBy;
var user = e.Tweet.CreatedBy;
var tweet = new Gof.Twitter.Tweet
{
Id = e.Tweet.Id,
TimeLineUser = new Gof.Twitter.User {
Alias = user.ScreenName, Name = user.Name, Id = user.Id
},
Author = new Gof.Twitter.User {
Alias = author.ScreenName, Name = author.Name, Id = author.Id
},
Content = e.Tweet.Text,
Date = e.Tweet.TweetLocalCreationDate,
IsRetweet = e.Tweet.IsRetweet,
Language = e.Tweet.Language.ToString(),
Hashtags = e.Tweet.Hashtags.Select(s => new Tuple <int[], string>(s.Indices, s.Text)),
Raw = Newtonsoft.Json.JsonConvert.SerializeObject(e.Tweet),
Url = e.Tweet.Url
};
return(tweet);
}
private async Task saveTweet(MatchedTweetReceivedEventArgs e, string keyword)
{
var tweet = formatTweet(e);
tweet.Keyword = keyword;
//we use keyword hashcode as partition key, it is assumed to be sparse
IPersistence persistence = ServiceExtensions.GetPersistenceService(keyword);
try
{
if (e.Tweet.IsRetweet)
{
await persistence.SaveReTweetAsync(tweet);
}
else
{
await persistence.SaveTweetAsync(tweet);
}
}
catch (Exception ex)
{
ServiceEventSource.Current.ServiceMessage(this, "Tweet store failed: {0}\r\n\t{1}", e.Tweet.Text, ex.Message);
throw;
}
}
private Task saveTweet(MatchedTweetReceivedEventArgs e)
{
Gof.Twitter.Tweet tweet = formatTweet(e);
IPersistence persistence = ServiceExtensions.GetPersistenceService(e.Tweet.CreatedBy.Name);
return(persistence.SaveRawTweetAsync(tweet));
}
private void C_ProcessTweet(object sender, MatchedTweetReceivedEventArgs args)
{
var message = BuildQueueMessage(args.Tweet);
_rabbitPublisher.Publish <QueueMessage>(message, _routingKey);
CheckTimeToUpdateTickers();
}
private void OnMatchingTweetReceived(object sender, MatchedTweetReceivedEventArgs args)
{
if (_store.UserTracked(args.Tweet.CreatedBy.Id))
{
_logger.LogInformation("Received Tweet {0} by user {1}", args.Tweet.Id, args.Tweet.CreatedBy.Id);
_ = AddAndReadTweet(args.Tweet.Id);
}
}
private async void ChangeTextMethodAsync(object sender, MatchedTweetReceivedEventArgs e)
{
tweet = "sgdfhj";
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
tweetText.Text = e.Tweet.Text;
// Update UI
});
}
private async void OnTweetReceivedAsync(object sender, MatchedTweetReceivedEventArgs messageEventArgs)
{
// ProcessAsync へバイパスするリクエストを行う。
var res = await botTwitterApiClient.PostAsync("",
new StringContent(JsonConvert.SerializeObject(messageEventArgs.Tweet.TweetDTO)));
if ((int)res.StatusCode >= 300)
{
throw new IOException($"Tweet process request failed. {res.StatusCode}");
}
}
public static void onTweetReceived(Object sebder, MatchedTweetReceivedEventArgs args)
{
//if (args.Tweet.Coordinates != null)
{
Console.WriteLine("tweet with coords!");
Console.WriteLine(args.Tweet.Text);
return;
}
Console.WriteLine("no coords");
}
private static void OnMatchedTweet(object sender, MatchedTweetReceivedEventArgs args)
{
var sanitized = sanitize(args.Tweet.FullText); //Sanitize Tweet
var sentence = new Sentence(sanitized);
//Output Tweet and Sentiment
Console.WriteLine(sentence.Sentiment + "|" + args.Tweet);
//Dispose of Sentence object
sentence = null;
}
private IReadOnlyDictionary <string, object> GetBindingData(MatchedTweetReceivedEventArgs value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
Dictionary <string, object> bindingData = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
bindingData.Add("TwitterTrigger", value);
return(bindingData);
}
public async Task ProcessTweetAsync(string track, MatchedTweetReceivedEventArgs args)
{
var responseDocument = await MakeRequest(args.Tweet.FullText);
var tweetSentiment = new TweetSentiment
{
FullText = args.Tweet.FullText,
Score = responseDocument.Score
};
_tweetsRepository.SaveTweet(args);
_tweetsRepository.SaveSentiment(tweetSentiment);
}
public async Task StartAsync(string url)
{
ITwitterRequest createTwitterRequest()
{
var queryBuilder = new StringBuilder(url);
AddBaseParametersToQuery(queryBuilder);
var request = _client.CreateRequest();
request.Query.Url = queryBuilder.ToString();
request.Query.HttpMethod = HttpMethod.GET;
return(request);
}
void onJsonReceived(string json)
{
RaiseJsonObjectReceived(json);
if (IsEvent(json))
{
TryInvokeGlobalStreamMessages(json);
return;
}
var tweet = _factories.CreateTweet(json);
var detectedTracksAndActions = _streamTrackManager.GetMatchingTracksAndActions(tweet.FullText);
var detectedTracks = detectedTracksAndActions.Select(x => x.Item1);
var eventArgs = new MatchedTweetReceivedEventArgs(tweet, json)
{
MatchingTracks = detectedTracks.ToArray(),
};
if (detectedTracksAndActions.Any())
{
eventArgs.MatchOn = MatchOn.TweetText;
RaiseTweetReceived(eventArgs);
RaiseMatchingTweetReceived(eventArgs);
}
else
{
RaiseTweetReceived(eventArgs);
RaiseNonMatchingTweetReceived(new TweetEventArgs(tweet, json));
}
}
await _streamResultGenerator.StartAsync(onJsonReceived, createTwitterRequest).ConfigureAwait(false);
}
private static void OnMatchedTweet_AnalyseUsing_SimpleNetNlp(object sender, MatchedTweetReceivedEventArgs args)
{
Console.WriteLine("**********************************New match tweet received*********************");
var sanitized = sanitize(args.Tweet.FullText);
var sentence = new Sentence(sanitized);
Console.WriteLine("---------------------------------------");
Console.WriteLine($"sentence :- {sentence.ToString()}");
Console.WriteLine("---------------------------------------");
Console.WriteLine($"tweet :- {args.Tweet}");
Console.WriteLine("---------------------------------------");
Console.WriteLine($"Statement's sentiments are :----- {sentence.Sentiment}");
Console.WriteLine("***********************************************************************");
}
public Task <ITriggerData> BindAsync(object value, ValueBindingContext context)
{
MatchedTweetReceivedEventArgs tweetEvent = value as MatchedTweetReceivedEventArgs;
if (tweetEvent == null)
{
string tweetInfo = value as string;
tweetEvent = GetEventArgsFromString(tweetInfo);
}
IReadOnlyDictionary <string, object> bindingData = GetBindingData(tweetEvent);
return(Task.FromResult <ITriggerData>(new TriggerData(null, bindingData)));
}
public async Task ProcessTweetAsync(string keyword, MatchedTweetReceivedEventArgs args)
{
var responseDocument = await MakeRequest(args.Tweet.FullText);
var tweetSentiment = new TweetSentiment
{
FullText = args.Tweet.FullText,
Score = responseDocument.Score
};
Console.WriteLine($"[{DateTime.Now}] - Tweet: {tweetSentiment.FullText}. Sentiment: {tweetSentiment.Score}");
await _tweetsRepository.SaveTweetAsync(args, keyword, tweetSentiment);
}
public void SaveTweet(MatchedTweetReceivedEventArgs args)
{
var fields = new Dictionary <string, object>
{
{ "text", args.Tweet.Text },
{ "screen_name", args.Tweet.CreatedBy.UserIdentifier.ScreenName },
{ "isRetweet", args.Tweet.IsRetweet },
{ "retweetCount", args.Tweet.RetweetCount },
{ "favorited", args.Tweet.Favorited },
{ "favoriteCount", args.Tweet.FavoriteCount },
{ "created_at", args.Tweet.CreatedAt }
};
_metricsCollectorWrapper.Write("tweet", fields);
}
public MatchedTweetReceivedEventArgs GetMatchingTweetEventArgsAndRaiseMatchingElements(ITweet tweet, string json, MatchOn matchOn)
{
var matchingTracksEventArgs = new MatchedTweetReceivedEventArgs(tweet, json);
var matchingTrackAndActions = new Dictionary <string, Action <ITweet> >();
var matchingLocationsAndActions = new Dictionary <ILocation, Action <ITweet> >();
var matchingFollowersAndActions = new Dictionary <long, Action <ITweet> >();
var matchingQuotedTrackAndActions = new Dictionary <string, Action <ITweet> >();
var matchingQuotedLocationsAndActions = new Dictionary <ILocation, Action <ITweet> >();
var matchingQuotedFollowersAndActions = new Dictionary <long, Action <ITweet> >();
UpdateMatchesBasedOnTweetText(tweet, matchOn, matchingTrackAndActions, matchingTracksEventArgs, matchingQuotedTrackAndActions);
UpdateMatchesBasedOnUrlEntities(tweet, matchOn, matchingTrackAndActions, matchingTracksEventArgs, matchingQuotedTrackAndActions);
UpdateMatchesBasedOnHashTagEntities(tweet, matchOn, matchingTrackAndActions, matchingTracksEventArgs, matchingQuotedTrackAndActions);
UpdateMatchesBasedOnUserMentions(tweet, matchOn, matchingTrackAndActions, matchingTracksEventArgs, matchingQuotedTrackAndActions);
UpdateMatchesBasedOnSymbols(tweet, matchOn, matchingTrackAndActions, matchingTracksEventArgs, matchingQuotedTrackAndActions);
UpdateMatchesBasedOnTweetLocation(tweet, matchOn, matchingLocationsAndActions, matchingTracksEventArgs, matchingQuotedLocationsAndActions);
UpdateMatchesBasedOnTweetCreator(tweet, matchOn, matchingFollowersAndActions, matchingTracksEventArgs, matchingQuotedFollowersAndActions);
UpdateMatchesBasedOnTweetInReplyToUser(tweet, matchOn, matchingFollowersAndActions, matchingTracksEventArgs, matchingQuotedFollowersAndActions);
var matchingTracks = matchingTrackAndActions.Select(x => x.Key).ToArray();
var matchingLocations = matchingLocationsAndActions.Select(x => x.Key).ToArray();
var matchingFollowers = matchingFollowersAndActions.Select(x => x.Key).ToArray();
matchingTracksEventArgs.MatchingTracks = matchingTracks;
matchingTracksEventArgs.MatchingLocations = matchingLocations;
matchingTracksEventArgs.MatchingFollowers = matchingFollowers;
var matchingQuotedTracks = matchingQuotedTrackAndActions.Select(x => x.Key).ToArray();
var matchingQuotedLocations = matchingQuotedLocationsAndActions.Select(x => x.Key).ToArray();
var matchingQuotedFollowers = matchingQuotedFollowersAndActions.Select(x => x.Key).ToArray();
matchingTracksEventArgs.QuotedTweetMatchingTracks = matchingQuotedTracks;
matchingTracksEventArgs.QuotedTweetMatchingLocations = matchingQuotedLocations;
matchingTracksEventArgs.QuotedTweetMatchingFollowers = matchingQuotedFollowers;
var allMatchingTracks = matchingTrackAndActions.MergeWith(matchingQuotedTrackAndActions);
var allMatchingLocations = matchingLocationsAndActions.MergeWith(matchingQuotedLocationsAndActions);
var allMatchingFollowers = matchingFollowersAndActions.MergeWith(matchingQuotedFollowersAndActions);
CallMultipleActions(tweet, allMatchingTracks.Select(x => x.Value));
CallMultipleActions(tweet, allMatchingLocations.Select(x => x.Value));
CallMultipleActions(tweet, allMatchingFollowers.Select(x => x.Value));
return(matchingTracksEventArgs);
}
public async Task StartStreamAsync(string url)
{
Func <ITwitterQuery> generateTwitterQuery = delegate
{
var queryBuilder = new StringBuilder(url);
AddBaseParametersToQuery(queryBuilder);
return(_twitterQueryFactory.Create(queryBuilder.ToString(), HttpMethod.GET, Credentials));
};
Action <string> generateTweetDelegate = json =>
{
RaiseJsonObjectReceived(json);
var tweet = _tweetFactory.GenerateTweetFromJson(json);
if (tweet == null)
{
TryInvokeGlobalStreamMessages(json);
return;
}
var detectedTracksAndActions = _streamTrackManager.GetMatchingTracksAndActions(tweet.Text);
var detectedTracks = detectedTracksAndActions.Select(x => x.Item1);
var eventArgs = new MatchedTweetReceivedEventArgs(tweet)
{
MatchingTracks = detectedTracks.ToArray(),
};
if (detectedTracksAndActions.Any())
{
eventArgs.MatchOn = MatchOn.TweetText;
RaiseTweetReceived(eventArgs);
RaiseMatchingTweetReceived(eventArgs);
}
else
{
RaiseTweetReceived(eventArgs);
RaiseNonMatchingTweetReceived(new TweetEventArgs(tweet));
}
};
await _streamResultGenerator.StartStreamAsync(generateTweetDelegate, generateTwitterQuery);
}
public async Task FilteredStream_UrlMatching()
{
if (!EndToEndTestConfig.ShouldRunEndToEndTests)
{
return;
}
var stream = _tweetinviTestClient.Streams.CreateFilteredStream();
stream.AddTrack("twitter.com");
stream.AddTrack("facebook.com");
stream.AddTrack("amazon.com");
stream.AddTrack("apple.com");
MatchedTweetReceivedEventArgs matchedTweetEvent = null;
stream.MatchingTweetReceived += (sender, args) =>
{
matchedTweetEvent = args;
_logger.WriteLine($"Tweet matched via {args.MatchOn.ToString()}");
_logger.WriteLine(matchedTweetEvent.ToString());
stream.Stop();
};
var runStreamTask = Task.Run(async() =>
{
_logger.WriteLine("Before starting stream");
await stream.StartMatchingAllConditionsAsync();
_logger.WriteLine("Stream completed");
});
// it can take a while before receiving matching tweets
var delayTask = Task.Delay(TimeSpan.FromMinutes(2));
var task = await Task.WhenAny(runStreamTask, delayTask);
if (task != runStreamTask)
{
throw new TimeoutException();
}
Assert.Equal(matchedTweetEvent.MatchOn, MatchOn.URLEntities);
Assert.True(matchedTweetEvent.MatchOn == MatchOn.URLEntities || matchedTweetEvent.QuotedTweetMatchOn == MatchOn.URLEntities);
await Task.Delay(TimeSpan.FromSeconds(10)); // this is for preventing Enhance Your Calm message from Twitter
}
public static void printTweet(object sender, MatchedTweetReceivedEventArgs arguments)
{
if (arguments.Tweet.Language != Tweetinvi.Core.Enum.Language.English)
{
Console.Write(arguments.Tweet.Language.ToString().Substring(0, 3) + " ");
return;
}
if (arguments.Tweet.Coordinates == null)
{
Console.Write("CN ");
return;
}
// create an object of the data we want to keep
FileLine current = new FileLine()
{
Id = total, TweetId = arguments.Tweet.Id, Latitude = arguments.Tweet.Coordinates.Latitude, Longitude = arguments.Tweet.Coordinates.Longitude, Text = arguments.Tweet.Text
};
// url encode the text of the tweet to avoid messy characters in files
current.Text = HttpUtility.UrlEncode(current.Text);
// convert to json
var json = JsonConvert.SerializeObject(current);
// add to our collection of lines
lines.Add(json);
// time to write a file
if (count > linesPerFile)
{
string path = filePath + "\\TweetFile" + fileCount++ + ".tweet";
File.WriteAllLines(path, lines);
lines.Clear();
count = 0;
}
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("current file count: " + count++ + " total tweet count: " + total++);
Console.WriteLine();
Console.WriteLine();
}
public void ProcessTweetAsyncTest()
{
// Arrange
const string keyword = "I am happy!";
var tweetsRepository = new Mock <ITweetsRepository>();
var configuration = new Mock <ITextAnalyticsConfiguration>();
var handlerMock = new Mock <HttpMessageHandler>(MockBehavior.Strict);
handlerMock
.Protected()
// Setup the PROTECTED method to mock
.Setup <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>()
)
// prepare the expected response of the mocked http call
.ReturnsAsync(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(
"{\r\n\"documents\":[\r\n{\r\n\"score\":0.9999237060546875,\r\n\"id\":\"1\"\r\n}\r\n],\r\n\"errors\":[]\r\n}")
})
.Verifiable();
// use real http client with mocked handler here
var httpClient = new HttpClient(handlerMock.Object);
var tweetProcessor = new TweetProcessor(tweetsRepository.Object, configuration.Object, httpClient);
var tweet = new Mock <ITweet>();
tweet.SetupGet(x => x.FullText).Returns(keyword);
var matchedTweetReceivedEventArgs = new MatchedTweetReceivedEventArgs(tweet.Object, "");
// Act
tweetProcessor.ProcessTweetAsync(keyword, matchedTweetReceivedEventArgs).Wait();
// Assert
tweetsRepository.Verify(x => x.SaveTweet(matchedTweetReceivedEventArgs));
tweetsRepository.Verify(x => x.SaveSentiment(It.Is <TweetSentiment>(t =>
t.FullText == "I am happy!" && Math.Abs(t.Score - 0.9999237060546875) < 0.01)));
}
