public async Task <IEnumerable <ITweetDTO> > GetTwitterResults(string placeName, double latitude, double longitude)
{
// Set up your credentials
var appCreds = Auth.SetApplicationOnlyCredentials(_apiKeyService.GetApiKey(ApiType.Twitter), _apiKeyService.GetApiSecret(ApiType.Twitter), true);
var searchParameter = new SearchTweetsParameters(placeName)
{
GeoCode = new GeoCode(latitude, longitude, 10, DistanceMeasure.Miles),
TweetSearchType = TweetSearchType.OriginalTweetsOnly,
SearchType = SearchResultType.Recent,
MaximumNumberOfResults = 30,
//Until = DateTime.UtcNow
};
IEnumerable <ITweet> tweets = await SearchAsync.SearchTweets(searchParameter);
if (tweets.Count() == 0)
{
searchParameter = new SearchTweetsParameters(placeName) //Not limiting by geocode for more results
{
SearchType = SearchResultType.Popular,
MaximumNumberOfResults = 30,
};
tweets = await SearchAsync.SearchTweets(searchParameter);
}
var tweetsDistinctUsers = tweets.GroupBy(t => t.CreatedBy.IdStr).Select(g => g.First());
return(tweetsDistinctUsers.Select(x => x.TweetDTO));
}
public async static Task <string> GetTweets(string query)
{
List <TweetSendData> tweetsendData = new List <TweetSendData>();
Auth.SetUserCredentials(creds.ConsumerKey, creds.ConsumerSecret, creds.AccessToken, creds.AccessSecret);
//var tweets = await SearchAsync.SearchTweets(query);
Tweets = await SearchAsync.SearchTweets(query);
List <Tweetinvi.Models.ITweet> tweetList = Tweets.ToList();
foreach (Tweetinvi.Models.ITweet item in tweetList)
{
var k = new TweetSendData()
{
TweetID = item.Id,
Tweet = item.FullText,
HashTags = item.Hashtags,
coordinates = item.Coordinates
};
if (item.Place != null)
{
k.PlaceName = item.Place.Name;
k.Country = item.Place.Country;
}
tweetsendData.Add(k);
}
string tweetJson = JsonConvert.SerializeObject(tweetsendData);
return(tweetJson);
}
public async Task <MessagesQueryResult> GetNumberAsync(int number, string hashtag)
{
var searchParameter = new SearchTweetsParameters(hashtag)
{
MaximumNumberOfResults = number
};
IEnumerable <ITweet> tweets = await SearchAsync.SearchTweets(searchParameter);
TwitterMessageResultMapper mapper = new TwitterMessageResultMapper();
return(mapper.MapBunch(tweets));
}
public async Task <MessagesQueryResult> GetSinceLastIdAsync(long id, string hashtag)
{
var searchParameter = new SearchTweetsParameters(hashtag)
{
SinceId = id
};
IEnumerable <ITweet> tweets = await SearchAsync.SearchTweets(searchParameter);
TwitterMessageResultMapper mapper = new TwitterMessageResultMapper();
return(mapper.MapBunch(tweets));
}
public static async Task <string> GetTweets(string symbol)
{
//TWITTER API CODE
Auth.SetUserCredentials(TwitterKeys.CONSUMER_KEY, TwitterKeys.CONSUMER_SECRET, TwitterKeys.ACCESS_TOKEN, TwitterKeys.ACCESS_SECRET_TOKEN);
TweetinviEvents.QueryBeforeExecute += (sender, args) =>
{
Console.WriteLine(args.QueryURL);
};
var authenticatedUser = User.GetAuthenticatedUser();
if (string.IsNullOrWhiteSpace(symbol))
{
return(null);
}
var searchParameters = new SearchTweetsParameters(symbol)
{
MaximumNumberOfResults = 2
};
IEnumerable <ITweet> tweets = await SearchAsync.SearchTweets(searchParameters);
ITweet a = tweets.ToArray <ITweet>()[0];
Console.WriteLine(tweets);
return(a.FullText);
//CODE FROM EXAMPLE
/*
* if (string.IsNullOrWhiteSpace(symbol))
* return null;
*
* string url = $"http://finance.yahoo.com/d/quotes.csv?s={symbol}&f=sl1";
* string csv;
* using (System.Net.WebClient client = new System.Net.WebClient())
* {
* csv = await client.DownloadStringTaskAsync(url).ConfigureAwait(false);
* }
* string line = csv.Split('\n')[0];
* string price = line.Split(',')[1];
*
* double result;
* if (double.TryParse(price, out result))
* return result;
*
* return null;
*/
}
protected async Task Submit()
{
if (!string.IsNullOrEmpty(Identity.Name))
{
IsSearchInProgress = true;
Auth.SetUserCredentials(Configuration["TWITTER_CONSUMER_KEY"], Configuration["TWITTER_CONSUMER_SECRET"],
Configuration["TWITTER_ACCESS_TOKEN"], Configuration["TWITTER_ACCESS_TOKEN_SECRET"]);
var searchResults = await SearchAsync.SearchUsers(Identity.Name);
if (searchResults != null && searchResults.Any())
{
Users = new List <TwitterUser>();
foreach (var user in searchResults)
{
var faces = FaceDetectionClient.DetectFace(user.ProfileImageUrlFullSize);
if (faces.Any())
{
var isIdentical = false;
var confidence = 0.0;
if (!string.IsNullOrEmpty(FaceId))
{
var face1 = new Guid(FaceId);
var face2 = new Guid(faces.FirstOrDefault());
var verificationResult = FaceDetectionClient.VerifyFaces(face1, face2);
isIdentical = verificationResult.IsIdentical;
confidence = verificationResult.Confidence;
}
Users.Add(new TwitterUser()
{
Id = user.Id,
Name = user.Name,
ScreenName = user.ScreenName,
Info = user.Description,
IsVerified = user.Verified,
ProfilePhoto = user.ProfileImageUrlFullSize,
IsIdentical = isIdentical,
Confidence = confidence
});
}
}
}
IsSearchInProgress = false;
}
StateHasChanged();
}
public DataTable SerachGlobal(string term, int?cid, int?sid)
{
List <SearchTypes> types...; /* load types from db */
SearchAsync async = new SearchAsync(SearchIndex);
AsyncCallback callBack = new AsyncCallback(ProcessCallBack);
foreach (SearchType t in types)
{
async.BeginInvoke(t.searchtypeid, term, cid, sid, callBack, null);
}
do
{
Thread.Sleep(100);
}while(tables == null || tables.Count < types.Count);
/* combine the tables */
}
public async static Task <List <MultiLanguageInput> > GetTweets(string query)
{
List <MultiLanguageInput> TweetInput = new List <MultiLanguageInput>();
Auth.SetUserCredentials(creds.ConsumerKey, creds.ConsumerSecret, creds.AccessToken, creds.AccessSecret);
//var tweets = await SearchAsync.SearchTweets(query);
Tweets = await SearchAsync.SearchTweets(query);
List <Tweetinvi.Models.ITweet> tweetList = Tweets.ToList();
int i = 0;
foreach (Tweetinvi.Models.ITweet item in tweetList)
{
var k = new MultiLanguageInput("en", i.ToString(), item.FullText);
TweetInput.Add(k);
i++;
}
return(TweetInput);
}
public async Task <ICommandResult> Execute(TwitterJobTask task)
{
var tweetsParameters = SearchParams(task.Tag, TimeSpan.FromMinutes(task.Interval));
var tweets = await SearchAsync.SearchTweets(tweetsParameters);
tweets = tweets?.Where(x => x.CreatedAt > tweetsParameters.Since).ToList();
var fail = ExceptionHandler.GetLastException()?.TwitterDescription;
if (!String.IsNullOrEmpty(fail))
{
logger.LogError(
LoggingEvents.EXCEPTION_GET_TWITTER_MESSAGE,
"Failed to get messages by {hashtag} with {error}",
task.Tag.TagWithHash,
fail);
}
return(await queue.EnqueueMany(tweets));
}
private void ProcessCallBack(IAsyncResult result)
{
AsyncResult asyncResult = (AsyncResult)result;
SearchAsync async = (SearchAsync)asyncResult.AsyncDelegate;
if (tables == null)
{
tables = new List <DataTable>();
}
try
{
tables.Add(async.EndInvoke(result));
}
catch (Exception ex)
{
/* handle error */
tables.Add(null);
}
}
public async Task <IQueryResult> GetAllAsync(HashTagWord hashtag)
{
ISearchTweetsParameters tweetsParameters = new SearchTweetsParameters(hashtag.TagWithHash);
tweetsParameters.TweetSearchType = TweetSearchType.OriginalTweetsOnly;
IEnumerable <ITweet> tweets = await SearchAsync.SearchTweets(tweetsParameters);
var fail = ExceptionHandler.GetLastException()?.TwitterDescription;
if (!String.IsNullOrEmpty(fail))
{
logger.LogError(
LoggingEvents.EXCEPTION_GET_TWITTER_MESSAGE,
"Failed to get messages by {hashtag} with {error}",
hashtag,
fail);
}
var mapper = new TwitterMessageResultMapper();
return(mapper.MapBunch(tweets));
}
private Task <IEnumerable <ITweet> > GetPostsByQuery(
string query,
int maximumResults,
DateTime?since)
{
Task <IEnumerable <ITweet> > Search()
{
var parameters = new SearchTweetsParameters(query)
{
MaximumNumberOfResults = maximumResults
};
if (since != null)
{
parameters.Since = (DateTime)since;
}
return(SearchAsync.SearchTweets(parameters));
}
return(_executer.Execute(Search));
}
static async Task SearchAndRetweetTweets(string[] terms, DateTime searchSince, IAuthenticatedUser me)
{
var filterTerms = new[] { "domain", "registration", "domainregistration", "@paul_dotnet" };
var query = string.Join(" OR ", terms);
var param = new SearchTweetsParameters(query)
{
Since = searchSince,
TweetSearchType = TweetSearchType.OriginalTweetsOnly,
Filters = TweetSearchFilters.Safe
};
var tweets = await SearchAsync.SearchTweets(param);
foreach (var tweet in tweets)
{
// Exclude tweets that contain excluded words.
if (filterTerms.Any(d => tweet.Text.Contains(d, StringComparison.OrdinalIgnoreCase)))
{
continue;
}
await tweet.PublishRetweetAsync();
}
}
public static async Task <List <TweetProcessingData> > GetTweets([ActivityTrigger] string lastTweetId, ILogger log)
{
log.LogInformation($"A_GetTweets: Getting new tweets after {lastTweetId}.");
KeyVaultAccessor kva = KeyVaultAccessor.GetInstance();
string apiKey = await kva.GetSecretAsync("TwitterApiKey"); // aka consumer key
string apiSecretKey = await kva.GetSecretAsync("TwitterApiSecretKey"); // aka consumer secret
string accessToken = await kva.GetSecretAsync("TwitterAccessToken");
string accessTokenSecret = await kva.GetSecretAsync("TwitterAccessTokenSecret");
string monitoredTwitterAccount = Environment.GetEnvironmentVariable("MonitoredTwitterAccount");
List <TweetProcessingData> tpds = new List <TweetProcessingData>(); // return value, empty list if Twitter connection failure
var userCredentials = Auth.SetUserCredentials(apiKey, apiSecretKey, accessToken, accessTokenSecret);
try
{
// This variable is not used later, but seems to leave an id for the library.
var authenticatedUser = User.GetAuthenticatedUser(userCredentials);
}
catch (AggregateException ae)
{
// Inserted try-catch after a seemingly intermittent exception that lead to
// the service stopping completely, 20210102, ca. 11 am.
log.LogWarning($"A_GetTweets: User authentication failure: {ae.Message}. Return no tweets and retry in next cycle.");
return(tpds);
}
// Note: The following does NOT get MaximumNumberOfResults tweets
// from after lastTweetId!!! Rather it gets the most recent
// tweets with the early limit defined by lastTweetId OR the
// defined maximum, whichever is more limiting!
// (Therefore, in order to test on past tweets, one may need
// to increase MaximumNumberOfResults considerably to get ALL
// tweets from the one targeted to the current one.
SearchTweetsParameters searchParameter = new SearchTweetsParameters($"from:{monitoredTwitterAccount}")
{
MaximumNumberOfResults = 15,
SinceId = long.Parse(lastTweetId)
};
IEnumerable <ITweet> tweets = null;
try
{
tweets = await SearchAsync.SearchTweets(searchParameter);
}
catch (Exception e)
{
// Inserted try-catch after a seemingly intermittent exception that lead to
// the service stopping completely, 20201213, ca. 7 am.
log.LogWarning($"A_GetTweets: SearchTweets failed with exception: {e.Message}");
}
if (tweets is null)
{
log.LogWarning($"A_GetTweets: Twitter connection failure. Return no tweets and retry in next cycle.");
return(tpds);
}
// Since the further processing can scramble the order again, we don't need to sort here.
foreach (var tweet in tweets)
{
// Copy the data that we need over to a serializable struct.
TweetProcessingData tpd = new TweetProcessingData();
tpd.IdStr = tweet.IdStr;
tpd.CreatedAt = tweet.CreatedAt;
tpd.FullText = tweet.FullText;
tpd.Hashtags = String.Join("|", tweet.Hashtags.Select(t => t.Text));
tpd.InReplyToStatusIdStr = tweet.InReplyToStatusIdStr;
tpd.Url = tweet.Url;
tpd.TextWithoutTags = TweetAnalysis.removeHashtagsFromText(tweet.FullText, tweet.Hashtags);
tpds.Add(tpd);
}
log.LogInformation($"A_GetTweets: Done, got {tweets.Count()} new tweets.");
return(tpds);
}
public async Task <List <Models.Tweet> > GetTweets(List <FollowItem> items)
{
List <Models.Tweet> res = new List <Models.Tweet>();
//1. launch tasks
List <Task <IEnumerable <ITweet> > > toWait = new List <Task <IEnumerable <ITweet> > >();
Dictionary <Task, FollowItem> taskToItem = new Dictionary <Task, FollowItem>();
foreach (var item in items)
{
if (item.Type == FollowType.HASHTAG || item.Type == FollowType.SEARCH)
{
var tmpT = SearchAsync.SearchTweets(item.Id);
toWait.Add(tmpT);
taskToItem.Add(tmpT, item);
}
else if (item.Type == FollowType.USER)
{
var tmpT = TimelineAsync.GetUserTimeline(item.Id);
toWait.Add(tmpT);
taskToItem.Add(tmpT, item);
}
else
{
//TODO
}
}
//2. wait for completion
await Task.WhenAll(toWait);
//3. Produce results from TweetInvi models
foreach (var task in toWait)
{
if (task.IsCompleted && !task.IsFaulted && !task.IsCanceled && task.Result != null)
{
foreach (var tweet in task.Result)
{
if (String.IsNullOrEmpty(tweet.InReplyToScreenName))
{
res.Add(new Models.Tweet()
{
InnerURL = tweet.Urls.Select(x => x.ExpandedURL).ToList(),
Content = tweet.Text,
Date = tweet.CreatedAt,
URL = tweet.Url,
Id = tweet.IdStr,
AssociatedID = taskToItem[task].Id,
AssociatedFollowItem = taskToItem[task],
MediaURI = tweet.Media.Select(item => new MediaItem()
{
URI = item.MediaURL
}).ToList(),
User = new Models.User()
{
Name = tweet.CreatedBy.Name,
ImageURI = tweet.CreatedBy.ProfileImageUrl400x400
}
});
}
}
}
}
//4. order results
res = res.OrderBy(x => new DateTimeOffset(x.Date)).Reverse().ToList();
return(res);
}
