static void Main(string[] args)
{
var tweets = new List <ITweet>();
Auth.SetUserCredentials("CONSUMER_KEY", "CONSUMER_SECRET", "ACCESS_TOKEN", "ACCESS_TOKEN_SECRET");
// Если у вас нет ключей для твиттера, то подключитесь к локальному сервису
//var localSearcher = new LocalSearch("localhost", 5000);
long maxId = 0;
for (int i = 0; i < 15; i++)
{
var request = new SearchTweetsParameters("#Java,#C#")
{
Lang = LanguageFilter.English,
SearchType = SearchResultType.Recent,
MaximumNumberOfResults = 40,
MaxId = maxId, // https://developer.twitter.com/en/docs/tweets/timelines/guides/working-with-timelines.html
Filters = TweetSearchFilters.Hashtags
};
var searchResult = Search.SearchTweets(request).ToList();
//var searchResult = localSearcher.SearchTweets(request).ToList();//Search.SearchTweets(request).ToList();
tweets.AddRange(i == 0 ? searchResult : searchResult.Skip(1));
maxId = searchResult.Min(x => x.Id);
}
PrintResult(tweets);
}
public async Task <ITweet[]> GetTwittsByQuery(string Query, int RetweetMin)
{
// some code to illustrate how to catch Tweetinvi exceptions.
try
{
var user = await Client.Users.GetAuthenticatedUserAsync();
string newQuery = Query.Replace("HASHTAG", "#");
// var parameters = new SearchTweetsParameters("#UNBOXING tech min_retweets:2")
var parameters = new SearchTweetsParameters(newQuery + " min_retweets:" + RetweetMin)
{
IncludeEntities = true,
Lang = LanguageFilter.English,
SearchType = SearchResultType.Mixed,
TweetMode = TweetMode.Extended,
};
Client.Config.RateLimitTrackerMode = RateLimitTrackerMode.TrackAndAwait;
return(await Client.Search.SearchTweetsAsync(parameters));
}
catch (TwitterException te)
{
Console.WriteLine(te.Message);
return(null);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(null);
}
}
public static void TweetSearchHelper(LiteCollection <BsonDocument> tweetsCollection)
{
Console.Write("Enter Hashtag to search Tweets: ");
var hastag = Console.ReadLine();
var searchParameter = new SearchTweetsParameters(hastag)
{
MaximumNumberOfResults = maxNumberOfResults,
Filters = TweetSearchFilters.Hashtags
};
var matchingTweets = Search.SearchTweets(searchParameter);
Console.WriteLine("Tweets against Hashtag" + matchingTweets.Count());
foreach (var match in matchingTweets)
{
if (!tweetsCollection.Find(Query.EQ("TweetId", match.IdStr)).Any())
{
var document = new BsonDocument
{
{ "TweetId", match.IdStr },
{ "Tweet", match.Text },
{ "CreatedBy", match.CreatedBy.Name }
};
tweetsCollection.Insert(document);
}
}
}
private void SearchTweets(string searchQuery)
{
if (string.IsNullOrWhiteSpace(searchQuery) == false)
{
if (searchQuery.StartsWith("#") != true)
{
searchQuery = $"#{searchTextbox.Text}";
}
var tweetParams = new SearchTweetsParameters(searchQuery)
{
MaximumNumberOfResults = 100,
TweetSearchType = TweetSearchType.OriginalTweetsOnly,
};
try
{
Session[SessionKeys.Tweets] = Search.SearchTweets(tweetParams).ToDictionary(x => x.Id);
}
catch (Exception ex)
{
Session[SessionKeys.Tweets] = null;
}
}
}
public ViewResult SearchResults(IndexViewModel searchParams)
{
Auth.SetCredentials(MyCredentials.GenerateCredentials());
SearchTweetsParameters searchTweetsParameters = new SearchTweetsParameters(searchParams.Query)
{
SearchType = searchParams.Type,
MaximumNumberOfResults = searchParams.MaxResults
};
if (searchParams.HasLocation)
{
searchTweetsParameters.GeoCode.Coordinates.Latitude = searchParams.Lat;
searchTweetsParameters.GeoCode.Coordinates.Longitude = searchParams.Long;
// TODO: only miles for now...
searchTweetsParameters.GeoCode.DistanceMeasure = DistanceMeasure.Miles;
}
var matchingTweets = Search.SearchTweets(searchTweetsParameters);
if (searchParams.HasLocation)
{
matchingTweets = matchingTweets.Where(p => p.Coordinates != null || !p.CreatedBy.Location.IsNullOrEmpty());
}
// Store the search results in TweetRepository so they are available application-wide.
if (!TweetRepository.SearchResults.IsNullOrEmpty())
{
TweetRepository.SearchResults.Clear();
}
return(View(matchingTweets));
}
static void Main(string[] args)
{
Auth.SetUserCredentials(
TwitterConnectionInfo.ConsumerKey,
TwitterConnectionInfo.ConsumerSecret,
TwitterConnectionInfo.AccessToken,
TwitterConnectionInfo.AccessTokenSecret);
var searchParameter = new SearchTweetsParameters("Trump")
{
//GeoCode = new GeoCode(-122.398720, 37.781157, 1, DistanceMeasure.Miles),
Lang = LanguageFilter.English,
SearchType = SearchResultType.Recent,
MaximumNumberOfResults = 15,
//Until = new DateTime(2015, 06, 02),
//SinceId = 399616835892781056,
//MaxId = 405001488843284480,
//Filters = TweetSearchFilters.Images
};
var tweets = Search.SearchTweets(searchParameter);
foreach (var tweet in tweets)
{
Console.WriteLine($"Tweet: {tweet.FullText}");
}
Console.ReadLine();
}
public void SearchTweets_WithFilters_ReturnsExpectedQuery()
{
// arrange
var parameters = new SearchTweetsParameters("plop")
{
Lang = LanguageFilter.French,
Filters = TweetSearchFilters.Safe,
Locale = "ja",
Since = new DateTime(2000, 01, 11),
Until = new DateTime(2020, 03, 19),
GeoCode = new GeoCode(42, 43, 44, DistanceMeasure.Kilometers),
MaxId = 1042,
SinceId = 1043,
SearchType = SearchResultType.Mixed,
TweetMode = TweetMode.Extended,
PageSize = 50,
IncludeEntities = true,
CustomQueryParameters = { new Tuple <string, string>("hello", "world") }
};
// act
var url = _searchQueryGenerator.GetSearchTweetsQuery(parameters, null);
// assert
Assert.Equal(url, "https://api.twitter.com/1.1/search/tweets.json?q=plop%20filter%3Asafe&geocode=42%2C43%2C44km" +
"&lang=fr&locale=ja&result_type=mixed&count=50&since_id=1043&max_id=1042" +
"&since=2000-01-11&until=2020-03-19&include_entities=true&tweet_mode=extended&hello=world");
}
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 IEnumerable <Tweet> Get(TweetQuery parameter)
{
var search = new SearchTweetsParameters(parameter.Key)
{
SearchType = SearchResultType.Recent,
Lang = LanguageFilter.English,
Filters = TweetSearchFilters.None,
MaximumNumberOfResults = parameter.MaxQuantity,
Since = parameter.Since
};
var result = Search.SearchTweets(search);
return(result.Select(itweet => new Tweet
{
Id = Guid.NewGuid(),
TweetIdentifier = itweet.TweetDTO.IdStr,
Text = itweet.TweetDTO.Text,
Language = itweet.TweetDTO.Language.ToString(),
Key = parameter.Key,
Date = itweet.TweetDTO.CreatedAt,
Latitude = itweet.TweetDTO?.Coordinates?.Latitude ?? 0.0,
Longitude = itweet.TweetDTO?.Coordinates?.Longitude ?? 0.0,
Sentiment = 0
}));
}
public IEnumerable <ITweet> GetTweets(PullTweetViewModel model, APIDetails details)
{
try
{
// Get a AuthenticatedUser from a specific set of credentials
Auth.SetUserCredentials(details.ApiKey, details.ApiSecretKey, details.AccessToken, details.AccessTokenSecret);
//var authenticatedUser = User.GetAuthenticatedUser(userCredentials);
var from = Convert.ToDateTime(model.From);
var to = Convert.ToDateTime(model.To);
var searchParameter = new SearchTweetsParameters(model.Keyword)
{
//GeoCode = new GeoCode(9.0820, 8.6753, 1, DistanceMeasure.Miles),
Lang = LanguageFilter.English,
//SearchType = SearchResultType.Popular,
MaximumNumberOfResults = model.Quantity,
//Until = new DateTime(2019, 08, 02),
//Since = from.Date,
//Until = to.Date,
//SinceId = 399616835892781056,
//MaxId = 405001488843284480,
//Filters = TweetSearchFilters.Images | TweetSearchFilters.Verified
};
IEnumerable <ITweet> tweets = Search.SearchTweets(searchParameter);
return(tweets);
}
catch (Exception)
{
throw;
}
}
public TweetsModel GetTweets(int numberOfResults, bool adminOverview)
{
var umbracoHelper = new UmbracoHelper(UmbracoContext.Current);
var tweetsModel = new TweetsModel {
ShowAdminOverView = adminOverview
};
var member = umbracoHelper.MembershipHelper.GetCurrentMember();
if (member == null || member.IsHq() == false)
{
tweetsModel.ShowAdminOverView = false;
}
ITweet[] filteredTweets = { };
try
{
var tweets =
UmbracoContext.Current.Application.ApplicationCache.RuntimeCache.GetCacheItem <ITweet[]>("UmbracoSearchedTweets",
() =>
{
Auth.SetUserCredentials(ConfigurationManager.AppSettings["twitterConsumerKey"],
ConfigurationManager.AppSettings["twitterConsumerSecret"],
ConfigurationManager.AppSettings["twitterUserAccessToken"],
ConfigurationManager.AppSettings["twitterUserAccessSecret"]);
Tweetinvi.User.GetAuthenticatedUser();
var searchParameter = new SearchTweetsParameters("umbraco")
{
SearchType = SearchResultType.Recent
};
return(Search.SearchTweets(searchParameter).ToArray());
}, TimeSpan.FromMinutes(2));
var settingsNode = umbracoHelper.TypedContentAtRoot().FirstOrDefault();
if (settingsNode != null)
{
var usernameFilter = settingsNode.GetPropertyValue <string>("twitterFilterAccounts")
.ToLowerInvariant().Split(',').Where(x => x != string.Empty).ToArray();
var wordFilter = settingsNode.GetPropertyValue <string>("twitterFilterWords")
.ToLowerInvariant().Split(',').Where(x => x != string.Empty);
filteredTweets = tweets.Where(x =>
x.CreatedBy.UserIdentifier.ScreenName.ToLowerInvariant().ContainsAny(usernameFilter) ==
false &&
x.UserMentions.Any(m => m.ScreenName.ContainsAny(usernameFilter)) == false &&
x.Text.ToLowerInvariant().ContainsAny(wordFilter) == false &&
x.Text.StartsWith("RT ") == false)
.Take(numberOfResults)
.ToArray();
}
tweetsModel.Tweets = filteredTweets;
}
catch (Exception ex)
{
LogHelper.Error <ITweet>("Could not get tweets", ex);
}
return(tweetsModel);
}
public ActionResult Gundem_cek(string query)
{
var Result = Auth.ExecuteOperationWithCredentials(_credentials, () =>
{
var tweets = Tweetinvi.Timeline.GetHomeTimeline(100);
var profil = Tweetinvi.User.GetUserFromScreenName("saresare9416");
var tt = Tweetinvi.Trends.GetTrendsAt(23424969);
var gundem = tt.Trends;
var friends = Tweetinvi.User.GetFriends("saresare9416", 250).ToList();
var followers = Tweetinvi.User.GetFollowers("saresare9416", 250).ToList();
query = string.IsNullOrEmpty(query) ? "Bimser " : query;
var yol = new SearchTweetsParameters(query)
{
SearchType = SearchResultType.Mixed,
SearchQuery = query,
};
var twt = Search.SearchTweets(yol).ToList();
HomePage model = new HomePage()
{
Tweets = tweets.ToList(),
User = profil,
Trend = tt,
Gundem = gundem,
Friends = friends,
Yol = twt,
Followers = followers
}; return(model);
}
);
ViewBag.Message = "Your application description page.";
return(View(Result));
}
public IHttpActionResult GetLatestTweets(double latitude, double longitude)
{
// Force throwing exceptions
ExceptionHandler.SwallowWebExceptions = false;
try
{
// Setup search parameters
SearchTweetsParameters searchParameter = new SearchTweetsParameters(Constants.NOWPLAYING_HASHTAG)
{
SearchType = SearchResultType.Recent, //Recent tweets
MaximumNumberOfResults = Convert.ToUInt16(ConfigurationManager.AppSettings.Get("NumberOfLatestTweets")),
GeoCode = new GeoCode(latitude, longitude, 100, DistanceMeasure.Kilometers) //Look up in an 100km radius
};
// Perform the search
IEnumerable <ITweet> tweets = Search.SearchTweets(searchParameter);
// Return the list of OEmbed tweeds
// OEmbedTweet contains the HTML to comply with tweets displaying guidance (see https://developer.twitter.com/en/developer-terms/display-requirements.html)
List <IOEmbedTweet> oEmbeddedTweets = tweets.Select(Tweet.GetOEmbedTweet).ToList();
return(Ok(oEmbeddedTweets));
}
catch (Exception e)
{
return(InternalServerError(e));
}
}
public List <KeyValuePair <int, string> > SearchHashTagOnTwitter(string hashTag)
{
var result = new List <KeyValuePair <int, string> >();
var searchParameter = new SearchTweetsParameters("#" + hashTag)
{
//GeoCode = new GeoCode(-122.398720, 37.781157, 1, DistanceMeasure.Miles),
//Lang = LanguageFilter.English,
//SearchType = SearchResultType.Popular,
//MaximumNumberOfResults = 200,
//Until = new DateTime(2015, 06, 02),
//Since = new DateTime(2013, 12, 1),
//SinceId = 399616835892781056,
//MaxId = 405001488843284480,
//Filters = TweetSearchFilters.Images
};
var tweets = Search.SearchTweets(searchParameter);
if (tweets != null)
{
int i = 0;
foreach (var tweet in tweets)
{
result.Add(new KeyValuePair <int, string>(i, tweet.FullText));
++i;
}
}
return(result);
}
public List <Tuple <string, float?> > FetchTweets(string Query)
{
scores = new List <Tuple <string, float?> >();
try
{
var searchParameter = new SearchTweetsParameters(Query)
{
Lang = LanguageFilter.English,
SearchType = SearchResultType.Popular,
MaximumNumberOfResults = 20,
//Filters = TweetSearchFilters.
};
var tweets = Search.SearchTweets(searchParameter);
foreach (var tweet in tweets)
{
float? x = nlp.Analyze(tweet.FullText);
string y = tweet.GenerateOEmbedTweet().HTML;
scores.Add(new Tuple <string, float?>(y, x));
//Console.WriteLine(Environment.NewLine + "Sentiment Score: " + x.ToString() + " " + label + Environment.NewLine + "(" + tweet.FullText + ")");
}
}
catch (ArgumentException ex)
{
//Something went wrong with the arguments and request was not performed
scores.Add(new Tuple <string, float?>("Request parameters are invalid: '{0}'" + ex.Message, null));
}
catch (TwitterException ex)
{
// Twitter API Request has been failed; Bad request, network failure or unauthorized request
scores.Add(new Tuple <string, float?>("Something went wrong when we tried to execute the http request : '{0}'" + ex.TwitterDescription, null));
}
return(scores);
}
public IEnumerable <ITweetCash> GetTweetsByQuery(SearchTweetsParameters searchParameters,
ITwitterAppAccount account)
{
Auth.SetUserCredentials(account.ConsumerKey, account.ConsumerSecret,
account.AccessToken, account.AccessTokenSecret);
var user = User.GetAuthenticatedUser();
List <ITweet> tweets = Search.SearchTweets(searchParameters).ToList();
List <ITweetCash> tweetsToShow = new List <ITweetCash>();
ITweet tw = tweets.FirstOrDefault();
tweets?.ForEach(t => tweetsToShow.Add(new TweetCash()
{
PartitionKey = TweetCash.GeneratePartitionKey(account.Id),
RowKey = TweetCash.GenerateRowKey(t.CreatedAt, t.IdStr),
TweetId = t.IdStr,
Title = t.Text,
Author = t.CreatedBy.Name,
Date = t.CreatedAt,
UserImage = t.CreatedBy.ProfileImageUrl,
TweetImage = t.Media?.FirstOrDefault()?.MediaURL,
AccountId = account.Id,
TweetJSON = JsonConvert.SerializeObject(t.TweetDTO)
})
);
return(tweetsToShow);
}
protected void Page_Load(object sender, EventArgs e)
{
// For some reason this app throws random error when loading the page first time. I made this dirty fix to wait a little before actually loading the page.
// It seems to help
Thread.Sleep(500);
// Enable RateLimit Tracking. Tracks and waits, so in worst case the app stops working for 15 minutes as tokens are gained in 15 minute intervals
// Couldn't get TrackOnly method to work
RateLimit.RateLimitTrackerMode = RateLimitTrackerMode.TrackAndAwait;
if (!IsPostBack)
{
try
{
// Redirect to log in page if session user is null
if (Session["user"] == null)
{
Response.Redirect("LogIn.aspx");
}
var query = Request.Params.Get("query");
searchHeader.InnerText = "Search results for " + query;
user = (IAuthenticatedUser)Session["user"];
InitUserData(user);
// Gets 200 results
var searchParameter = new SearchTweetsParameters(query)
{
MaximumNumberOfResults = 200
};
matchingTweets = Tweetinvi.Search.SearchTweets(query);
}
catch (Exception ex)
{
lblError.Text = ex.Message;
}
GenerateSearchResults();
}
}
static void Main(string[] args)
{
Console.Write("Write a word to search for tweets:");
string search = Console.ReadLine();
Console.WriteLine();
Auth.SetUserCredentials("5BZmdJoR1y6XvTv9yUZ65t0qV", "TGZoRvV82wWFO6Sf4Hv40dQTavg3nnQLuHKMxA9QZmRCtr1HVX",
"81419467-QmwU8wIkVUtyoFptDG0f0j6YA1zVjtL2Zt0Albn08", "tBCe7qliVUuVFzrnvTMPnNGtKWdsaSyXPpnpteCUYYgZK");
//var user = User.GetAuthenticatedUser();
//Tweet.PublishTweet("I am learning webAPI with C#");
var searchParameter = new SearchTweetsParameters(search)
{
SearchType = SearchResultType.Recent,
MaximumNumberOfResults = 10
};
var tweets = Search.SearchTweets(searchParameter).ToArray();
foreach (var list in tweets)
{
Console.WriteLine(list.Text);
Console.WriteLine("--------------------------------------------------------------");
Console.WriteLine();
}
}
//Get sentiment for given keywords over {duration} days
public SentimentAnalysisResult GetSentiment(string[] keywords, int tweetCount = 100, bool translate = false)
{
List <ITweet> tweets = new List <ITweet>();
//Get all the tweets for each keyword
foreach (var keyword in keywords)
{
var searchParameter = new SearchTweetsParameters(keyword)
{
Filters = TweetSearchFilters.Images,
//SinceId = (int)(DateTime.UtcNow.AddDays(duration * -1).Subtract(new DateTime(1970, 1, 1))).TotalSeconds
};
if (!translate)
{
searchParameter.Lang = LanguageFilter.English;
}
var someTweets = Search.SearchTweets(searchParameter);
if (someTweets != null)
{
tweets.AddRange(someTweets);
}
else
{
throw new Exception("Twitter rate limit reached.");
}
}
//Translate them to sentiment results
SentimentIntensityAnalyzer analyzer = new SentimentIntensityAnalyzer();
string sanitizedTweet = Sanitize(tweets[0].FullText);
var results = analyzer.PolarityScores(sanitizedTweet);
//First result needs no math
SentimentAnalysisResult overallSentiment = new SentimentAnalysisResult()
{
Negative = results.Negative,
Neutral = results.Neutral,
Positive = results.Positive,
Compound = results.Compound,
ItemsChecked = 1
};
//Keep an average of the sentiment in the found tweets
for (int i = 1; i < tweets.Count(); i++)
{
sanitizedTweet = Sanitize(tweets[i].FullText);
results = analyzer.PolarityScores(sanitizedTweet);
overallSentiment.Negative = overallSentiment.Negative + (results.Negative - overallSentiment.Negative) / overallSentiment.ItemsChecked;
overallSentiment.Neutral = overallSentiment.Neutral + (results.Neutral - overallSentiment.Neutral) / overallSentiment.ItemsChecked;
overallSentiment.Positive = overallSentiment.Positive + (results.Positive - overallSentiment.Positive) / overallSentiment.ItemsChecked;
overallSentiment.Compound = overallSentiment.Compound + (results.Compound - overallSentiment.Compound) / overallSentiment.ItemsChecked;
overallSentiment.ItemsChecked++;
}
return(overallSentiment);
}
/// <summary>
/// Basic constructor to start a search and set the TweetList property.
/// </summary>
/// <param name="searchString">Pass in the SearchTweetsParameters from Tweetinvi</param>
public TwitterSearch(SearchTweetsParameters searchString)
{
var tweets = Search.SearchTweets(searchString);
List <ITweet> list = new List <ITweet>(tweets);
TweetList = list;
}
/// <summary>
/// Clase dedicada a buscar el tweet con mas impacto sobre el trending.
/// Puede no encontrar ninguno según el tiempo transcurrido
/// </summary>
public void PopularTweet()
{
//parámetros de busqueda
//1º Buscar por popularidad
//2º Devolver un único resultado
var searchParameter = new SearchTweetsParameters(obj)
{
SearchType = SearchResultType.Popular,
MaximumNumberOfResults = 1
};
var tweets = Search.SearchTweets(searchParameter);
//Extracción de datos
try
{
//Tweet
var tweet = tweets.ToList()[0];
//Fecha creación
lbl_tiempo.Content = tweet.CreatedAt.ToString();
//Texto
lbl_text.Text = tweet.Text;
//Interacciones
lbl_like.Content = Formato(tweet.FavoriteCount);
lbl_rt.Content = Formato(tweet.RetweetCount);
//Usuario
var user = tweet.CreatedBy;
//Imagen de perfil
img_profileSource.ImageSource = new BitmapImage(new Uri(user.ProfileImageUrl));
//Verificado
if (!user.Verified)
{
img_verificado.Visibility = Visibility.Hidden;
lbl_verificado.Visibility = Visibility.Hidden;
}
else
{
img_verificado.Visibility = Visibility.Visible;
lbl_verificado.Visibility = Visibility.Visible;
}
//Nombre usuario
lbl_name.Content = user.Name;
//Url
url = tweet.Url;
}catch (Exception)
{
//En caso de no encontrar se imprimirán datos predeterminados
lbl_text.Text = "No se ha encontrado un tweet destacado en estos momentos";
}
}
private SearchTweetsParameters GetParameter(string topic, string enrichmentItem, DateTime until)
{
var searchParameter = new SearchTweetsParameters($"\"{topic}\" {enrichmentItem} -filter:retweets");
searchParameter.Lang = Language;
searchParameter.Until = until;
searchParameter.MaximumNumberOfResults = 100;
return(searchParameter);
}
private void QueryTwitter(String paramHashtag)
{
try
{
var searchParameter = new SearchTweetsParameters(paramHashtag)
{
SearchType = SearchResultType.Recent,
TweetSearchType = TweetSearchType.OriginalTweetsOnly,
MaximumNumberOfResults = _settings.NumberOfResults,
SinceId = _sinceId,
Since = new DateTime(DateTime.UtcNow.Year, DateTime.UtcNow.Month, DateTime.UtcNow.Day),
};
List <ITweet> tweets = Search.SearchTweets(searchParameter).ToList();
if (tweets.Count > 0)
{
if (_isFirstTime)
{
InsertTweets(tweets);
_isFirstTime = false;
}
else if (tweets.Count == _settings.NumberOfResults)
{
stackPanelTweets.Children.Clear();
InsertTweets(tweets);
}
else
{
Int32 emptyPlaces = _settings.NumberOfResults - (_currentIndex + 1);
if (tweets.Count <= emptyPlaces)
{
UpdateTweetsMemory(tweets);
ShowNewTweetsOnScreen(tweets);
}
else
{
stackPanelTweets.Children.Clear();
Int32 numberToDelete = tweets.Count - emptyPlaces;
_currentIndex -= numberToDelete;
UpdateTweetsMemory(tweets);
ShowTweetsOnScreen();
}
}
}
}
catch (Exception Ex)
{
MessageBox.Show($"Application error: {Ex.Message}", "Tweets", MessageBoxButton.OK, MessageBoxImage.Error);
}
finally
{
_scrollViewer.ScrollToEnd();
_timerToCheckNewTweets.Interval = new TimeSpan(0, 0, _settings.NumberOfSecondsToCheckNewTweets);
}
}
/// <summary>
/// Searches tweets that contain keyword
/// </summary>
/// <param name="keyword">keyword that must contains in tweet</param>
/// <param name="numberOfTweetsToLoad">maximum number of tweets that will be loaded</param>
/// <returns>Collection of tweets</returns>
public IEnumerable <ITweet> SearchTweetByKeyword(string keyword, int numberOfTweetsToLoad)
{
var tweetSearchOptions = new SearchTweetsParameters(keyword)
{
MaximumNumberOfResults = numberOfTweetsToLoad
};
return(Search.SearchTweets(tweetSearchOptions));
}
public async Task Retweet(ILambdaContext context)
{
var creds = await SecretHelper.GetSecretAsync();
Auth.SetUserCredentials(creds.ConsumerKey, creds.ConsumerSecret, creds.AccessToken, creds.AccessSecret);
var searchTerms = new[] { "\".NET Framework\"", "\".NET Core\"", "\".NET 5\"", "dotnet", "dotnetcore", "_dotnetbot_" };
var searchSince = DateTime.UtcNow.Subtract(TimeSpan.FromMinutes(10));
var filterTerms = new[] { "domain", "registration", "domainregistration" };
var me = User.GetAuthenticatedUser();
foreach (var term in searchTerms)
{
var param = new SearchTweetsParameters(term)
{
Since = searchSince,
TweetSearchType = TweetSearchType.OriginalTweetsOnly,
Filters = TweetSearchFilters.Safe
};
var tweets = Search.SearchTweets(param);
foreach (var tweet in tweets)
{
// Exclude tweets that don't specifically mention search terms
if (!tweet.Text.Contains(term, StringComparison.OrdinalIgnoreCase))
{
continue;
}
// Exclude tweets that contain excluded words.
if (filterTerms.Any(d => tweet.Text.Contains(d)))
{
//This sends the questionable tweet to the DM's of the me.User
await Message.PublishMessageAsync($"Questionable Tweet : {tweet.Url}", User.GetUserFromScreenName($"{me.ScreenName}").Id);
continue;
}
// Exclude tweets that are from automated GitHub issues, except dotnetissues because
// it aggregates them rather than having one separate account for each.
if (tweet.CreatedBy.ScreenName.EndsWith("issues", StringComparison.OrdinalIgnoreCase) &&
!tweet.CreatedBy.ScreenName.EndsWith("dotnetissues", StringComparison.OrdinalIgnoreCase))
{
continue;
}
var retweetTask = tweet.PublishRetweetAsync();
var followTask = me.FollowUserAsync(tweet.CreatedBy.Id);
await retweetTask;
await followTask;
}
}
}
//public ActionResult Retweeters()
//{ var rliste = new List<Tweetinvi.Models.ITweet>();
// Auth.ExecuteOperationWithCredentials(_credentials, () =>
// {
// var r = Tweet.GetRetweets(10);
// rliste.AddRange(r);
// });
// return Json(true);
//}
public ActionResult Gundem(string query)
{
var result = Auth.ExecuteOperationWithCredentials(_credentials, () =>
{
query = string.IsNullOrEmpty(query) ? "Tweetinvi" : query;
//id = string.IsNullOrEmpty(id) ? "JFernweh_" : id;
var tweets2 = Tweetinvi.Timeline.GetHomeTimeline(50);
var tweets = tweets2 == null ? new List <ITweet>() : tweets2.ToList();
//var profil = Tweetinvi.User.GetUserFromScreenName(id);
//var tt = Tweetinvi.Trends.GetTrendsAt(23424969);
var trendler = Tweetinvi.Trends.GetTrendsAt(23424969).Trends.Take(10);
var trend_ler = trendler == null ? new List <ITrend>() : trendler.ToList();
//var ptimeline = Tweetinvi.User.GetUserFromScreenName(id).GetUserTimeline(50).ToList();
//var p_timeline = ptimeline == null ? new List<ITweet>() : ptimeline.ToList();
var searchParameter = new SearchTweetsParameters(query)
{
//GeoCode = new GeoCode(-122.398720, 37.781157, 1, DistanceMeasure.Miles),
SearchType = SearchResultType.Mixed,
//MaximumNumberOfResults = 100,
//Until = new DateTime(2017, 07, 02),
//SinceId = 399616835892781056,
//MaxId = 405001488843284480,
//Filters = TweetSearchFilters.Images,
SearchQuery = query,
};
var stweets = Search.SearchTweets(searchParameter).ToList();
var s_tweets = stweets == null ? new List <ITweet>() : stweets.ToList();
//var s_tweets = Tweetinvi.Search.SearchTweets(query).ToList();
//var userSearchParameter = new SearchUsersParameters(query)
//{
// SearchQuery=query,
//};
var users_search = Search.SearchUsers(query).Take(3);
var gundem_kullanici = users_search == null ? new List <IUser>(): users_search.ToList();
AnasayfaModel model = new AnasayfaModel()
{
Tweets = tweets,
//User = profil,
//Trend = tt,
Trendler = trend_ler,
//Profile_Tweets = p_timeline,
Gundem_Tweets = s_tweets,
Gundem_Kullanici = gundem_kullanici
};
return(model);
});
return(View(result));
}
static void Main(string[] args)
{
Console.WriteLine($"<{DateTime.Now}> - Bot Started");
TwitterLogIn logIntoTwitter = new TwitterLogIn(customer_key, customer_key_secret,
access_token, access_token_secret);
Console.WriteLine($"User: {logIntoTwitter.AuthenticatedUser}");
SearchTweetsParameters searchParameter = new SearchTweetsParameters("Turkey")
{
// GeoCode = new GeoCode(-122.398720, 37.781157, 1000, DistanceMeasure.Miles),
Lang = LanguageFilter.English,
//SearchType = SearchResultType.Popular,
MaximumNumberOfResults = 1000,
//Until = new DateTime(2019, 01, 02),
//SinceId = 399616835892781056,
//MaxId = 405001488843284480,
//Filters = TweetSearchFilters.Images
};
TwitterSearch searchTweets = new TwitterSearch(searchParameter);
foreach (var tweet in searchTweets.TweetList)
{
Console.WriteLine($"Created By: \n{tweet.CreatedBy}\n");
Console.WriteLine($"Place: \n{tweet.Place}\n");
Console.WriteLine($"Coordinates: \n{tweet.Coordinates}\n");
Console.WriteLine($"TweetDTO FavoriteCount: \n{tweet.TweetDTO.FavoriteCount}\n");
Console.WriteLine($"Favorited: \n{tweet.Favorited}\n");
Console.WriteLine($"Tweet Time: \n{tweet.CreatedAt}\n");
Console.WriteLine($"Tweet: \n{tweet}\n");
StringBuilder hashBuilder = new StringBuilder();
Console.WriteLine($"Tweet: \n{tweet}\n");
foreach (var hash in tweet.Hashtags)
{
hashBuilder.Append(hash + " ");
}
Console.WriteLine($"Hash Tags: \n{hashBuilder.ToString()}\n");
Console.WriteLine($"Retweet Count: \n{tweet.RetweetCount}\n");
Console.WriteLine($"Fav Count: \n{tweet.FavoriteCount}\n");
Console.WriteLine($"Tweet Text: \n{tweet.FullText}\n--------------------------------------");
}
searchTweets.CreateCsv(pathToSaveCsv);
Console.Read();
}
public IEnumerable <ITweet> GetTweets()
{
// Set up your credentials (https://apps.twitter.com)
Auth.SetUserCredentials("B1QeRBJ78iqcuRdkPhxeDe19r", "8yGJufH2ujGieDC1qHQ2WZmEA3gPHvCYtrOJRUuvyfObNXBi3q", "2387675090-2gq4MP0IQC04okCALMgsJmLbgxdVZ7abs2zH25L", "CCmBFpXcX14lMrmzJMJYzsDntOfPAS1jijVpUHvdC1bes");
var searchParameter = new SearchTweetsParameters("startup")
{
MaximumNumberOfResults = 30,
};
return(Search.SearchTweets(searchParameter));
}
private SearchTweetsParameters SearchParams(HashTagWord hashTag, TimeSpan span)
{
var tweetsParameters =
new SearchTweetsParameters(hashTag.TagWithHash)
{
TweetSearchType = TweetSearchType.OriginalTweetsOnly,
Since = DateTime.Now - span,
Filters = TweetSearchFilters.Hashtags
};
return(tweetsParameters);
}
public List <TweetModel> GetTweets(TweetSearchModel searchModel)
{
var searchParameter = new SearchTweetsParameters(searchModel.Query)
{
MaximumNumberOfResults = searchModel.MaxTweetCount
};
if (searchModel.IsTurkishOnly)
{
searchParameter.Lang = LanguageFilter.Turkish;
}
if (searchModel.MaxId > 0)
{
searchParameter.MaxId = searchModel.MaxId;
}
if (searchModel.SinceId > 0)
{
searchParameter.SinceId = searchModel.SinceId;
}
var matchingTweets = Search.SearchTweets(searchParameter);
var tweetModels = new List <TweetModel>();
if (matchingTweets != null)
{
foreach (var tweet in matchingTweets)
{
var tweetText = tweet.RetweetCount > 0 && tweet.RetweetedTweet != null ? "RT " + tweet.RetweetedTweet.FullText : tweet.FullText;
var tweetModel = new TweetModel
{
Id = tweet.Id.ToString(),
Text = tweetText,
URLFreeText = GetUrlFreeText(tweetText),
CreatedByAccountName = tweet.CreatedBy.ScreenName,
CreatedAt = tweet.CreatedAt,
Place = tweet.Place != null ? tweet.Place.FullName : string.Empty,
HashtagCount = tweet.Entities.Hashtags == null ? 0 : tweet.Entities.Hashtags.Count(),
MediaCount = tweet.Entities.Medias == null ? 0 : tweet.Entities.Medias.Count(),
SymbolCount = tweet.Entities.Symbols == null ? 0 : tweet.Entities.Symbols.Count(),
UrlCount = GetUrlOccuranceCount(tweetText),
UserMentionCount = tweet.UserMentions == null ? 0 : tweet.UserMentions.Count(),
IsRetweet = tweet.RetweetCount > 0 && tweet.RetweetedTweet != null ? 1 : 0,
RetweetRefId = tweet.RetweetCount > 0 && tweet.RetweetedTweet != null?tweet.RetweetedTweet.Id.ToString() : string.Empty,
RetweetedCount = tweet.RetweetCount > 0 && tweet.RetweetedTweet == null ? tweet.RetweetCount : 0
};
tweetModels.Add(tweetModel);
}
}
return(tweetModels);
}
