public static ConsumerOnlyCredentials LoadCredentials(
this ConsumerOnlyCredentials credentials,
TwitterApiConfig config
) => new ConsumerOnlyCredentials(config.ConsumerKey, config.ConsumerSecret)
{
BearerToken = config.BearerToken
};
public Task <ITwitterResult <IWebhookEnvironmentSubscriptionsDTO> > GetAccountActivitySubscriptionsAsync(IGetAccountActivitySubscriptionsParameters parameters, ITwitterRequest request)
{
var consumerCredentials = new ConsumerOnlyCredentials(request.Query.TwitterCredentials);
request.Query.Url = _accountActivityQueryGenerator.GetAccountActivitySubscriptionsQuery(parameters);
request.Query.HttpMethod = HttpMethod.GET;
request.Query.TwitterCredentials = new TwitterCredentials(consumerCredentials);
return(_twitterAccessor.ExecuteRequestAsync <IWebhookEnvironmentSubscriptionsDTO>(request));
}
public Task <ITwitterResult> UnsubscribeFromAccountActivityAsync(IUnsubscribeFromAccountActivityParameters parameters, ITwitterRequest request)
{
var consumerCredentials = new ConsumerOnlyCredentials(request.Query.TwitterCredentials);
request.Query.Url = _accountActivityQueryGenerator.GetUnsubscribeToAccountActivityQuery(parameters);
request.Query.HttpMethod = HttpMethod.DELETE;
request.Query.TwitterCredentials = new TwitterCredentials(consumerCredentials);
return(_twitterAccessor.ExecuteRequestAsync(request));
}
private async Task <ITwitterClient> CreateClient()
{
var consumerKey = Configuration["consumerKey"];
var consumerSecret = Configuration["consumerSecret"];
var consumerOnlyCredentials = new ConsumerOnlyCredentials(consumerKey, consumerSecret);
var appClientWithoutBearer = new TwitterClient(consumerOnlyCredentials);
var bearerToken = await appClientWithoutBearer.Auth.CreateBearerTokenAsync();
var appCredentials = new ConsumerOnlyCredentials(consumerKey, consumerSecret, bearerToken);
return(new TwitterClient(appCredentials));
}
static void Main(string[] args)
{
Sync.ExecuteTaskAsync(() =>
{
var consumerOnlyCredentials = new ConsumerOnlyCredentials("CONSUMER_TOKEN", "CONSUMER_SECRET")
{
ApplicationOnlyBearerToken = "BEARER_TOKEN"
};
IWebhookEnvironmentDTO[] webhookEnvironments = Webhooks.GetAllWebhookEnvironmentsAsync(consumerOnlyCredentials).Result;
webhookEnvironments.ForEach(env =>
{
Console.WriteLine(env.Name);
});
}).Wait();
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
var consumerOnlyCredentials = new ConsumerOnlyCredentials("CONSUMER_TOKEN", "CONSUMER_SECRET")
{
ApplicationOnlyBearerToken = "BEARER_TOKEN"
};
WebhookServerInitialization(app, consumerOnlyCredentials);
RegisterAccountActivities(consumerOnlyCredentials).Wait();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseMvc();
}
public static async Task Launch(string TwitterConsumerKey, string TwitterConsumerSecret)
{
var creds = new ConsumerOnlyCredentials(TwitterConsumerKey, TwitterConsumerSecret);
var tempClient = new TwitterClient(creds);
// Get OAuth Bearer token
var bearerToken = await tempClient.Auth.CreateBearerTokenAsync();
creds = new ConsumerOnlyCredentials(TwitterConsumerKey, TwitterConsumerSecret)
{
BearerToken = bearerToken
};
appClient = new TwitterClient(creds);
var tweetStream = appClient.StreamsV2.CreateSampleStream();
await StartListening(tweetStream);
}
/// <summary>
/// Uses credentials in IConfiguration to build an authenticated Twitter client.
/// </summary>
/// <returns></returns>
public async Task <TwitterClient> GetAuthenticatedTwitterClient()
{
_logger.LogDebug("Providing credentials");
var tempClient = new TwitterClient(new ConsumerOnlyCredentials(
_configuration["CONSUMER_KEY"],
_configuration["CONSUMER_SECRET"]));
var bearer = await tempClient.Auth.CreateBearerTokenAsync();
var appCreds = new ConsumerOnlyCredentials(new ConsumerOnlyCredentials(
_configuration["CONSUMER_KEY"],
_configuration["CONSUMER_SECRET"]))
{
BearerToken = bearer
};
return(new TwitterClient(appCreds));
}
public void Credentials()
{
if (!EndToEndTestConfig.ShouldRunEndToEndTests)
{
return;
}
var twitterCredentials = new TwitterCredentials("A", "B", "C", "D")
{
BearerToken = "E"
};
var consumerCreds = new ConsumerOnlyCredentials("A2", "B2", "E2");
TestSerializer <ITwitterCredentials, ITwitterCredentials>(twitterCredentials, creds =>
{
Assert.Equal(twitterCredentials.AccessToken, creds.AccessToken);
Assert.Equal(twitterCredentials.ConsumerKey, creds.ConsumerKey);
Assert.Equal(twitterCredentials.BearerToken, creds.BearerToken);
});
TestSerializer <ITwitterCredentials, IConsumerOnlyCredentials>(twitterCredentials, creds =>
{
Assert.Equal(twitterCredentials.ConsumerKey, creds.ConsumerKey);
Assert.Equal(twitterCredentials.BearerToken, creds.BearerToken);
});
TestSerializer <IConsumerOnlyCredentials, IConsumerOnlyCredentials>(consumerCreds, creds =>
{
Assert.Equal(consumerCreds.ConsumerKey, creds.ConsumerKey);
Assert.Equal(consumerCreds.ConsumerSecret, creds.ConsumerSecret);
Assert.Equal(consumerCreds.BearerToken, creds.BearerToken);
});
TestSerializer <IConsumerOnlyCredentials, ITwitterCredentials>(consumerCreds, creds =>
{
Assert.Equal(consumerCreds.ConsumerKey, creds.ConsumerKey);
Assert.Equal(consumerCreds.ConsumerSecret, creds.ConsumerSecret);
Assert.Equal(consumerCreds.BearerToken, creds.BearerToken);
});
}
public static async Task StartTwitterAPI(bool skip)
{
TwitterAPIDAO dao = new TwitterAPIDAO();
/*
* Since this is an app that does not need to store tweets/stats, we recreate the database each time.
* Normally, you would not build/maintain the database in code (at least with .Net)
*
*/
if (!skip)
{
dao.BuildSQliteDatabase();
}
var appCredentials = new ConsumerOnlyCredentials(System.Configuration.ConfigurationManager.AppSettings["TwitterKey"], System.Configuration.ConfigurationManager.AppSettings["TwitterSecret"])
{
BearerToken = System.Configuration.ConfigurationManager.AppSettings["TwitterBearerToken"]
};
var appClient = new TwitterClient(appCredentials);
/**
* This is looping through the tweets automatically. As long as the application is running. tweets will be saved to a sqllite table.
* The only time I have seen this fail is if I put a breakpoint within the receiver. This causes the connection to twitter to be severed.
* Also, since this is running in a seperate process, there is no blocking the other parts of the app!
*
*
*
*/
var sampleStreamV2 = appClient.StreamsV2.CreateSampleStream();
sampleStreamV2.TweetReceived += (sender, args) =>
{
bool hasUrl = false;
bool hasImage = false;
bool hasEmoji = false;
RegexPattern pattern = new RegexPattern();
var emojis = pattern.emoji.Matches(args.Tweet.Text);
foreach (System.Text.RegularExpressions.Match emj in emojis)
{
hasEmoji = true;
string text = "INSERT INTO emojis(value) VALUES(@value)";
List <SQLiteParameter> InnerParamList = new List <SQLiteParameter>
{
dao.NewParameter("value", emj.Value)
};
dao.RunSQLiteCommand(text, InnerParamList);
}
if (args.Tweet.Entities != null)
{
if (args.Tweet.Entities.Hashtags != null && args.Tweet.Entities.Hashtags.Count() > 0)
{
foreach (Tweetinvi.Models.V2.HashtagV2 hashtag in args.Tweet.Entities.Hashtags)
{
List <SQLiteParameter> InnerParamList = new List <SQLiteParameter>
{
dao.NewParameter("tag", hashtag.Tag)
};
string text = "INSERT INTO hashtags(tag) VALUES(@tag)";
dao.RunSQLiteCommand(text, InnerParamList);
}
}
if (args.Tweet.Entities.Urls != null && args.Tweet.Entities.Urls.Count() > 0)
{
hasUrl = true;
foreach (Tweetinvi.Models.V2.UrlV2 urlEntity in args.Tweet.Entities.Urls)
{
// No need to run string checkers we have already set hasImage.
if (!hasImage && (urlEntity.DisplayUrl.Contains("pic.twitter") || urlEntity.DisplayUrl.Contains("instagram")))
{
hasImage = true;
}
Uri tweetURL = new Uri(urlEntity.ExpandedUrl);
List <SQLiteParameter> InnerParamList = new List <SQLiteParameter>
{
dao.NewParameter("url", urlEntity.DisplayUrl),
dao.NewParameter("hostname", tweetURL.Host)
};
string text = "INSERT INTO urls(url, hostname) VALUES(@url, @hostname)";
dao.RunSQLiteCommand(text, InnerParamList);
}
}
if (args.Tweet.Entities.Mentions != null && args.Tweet.Entities.Mentions.Count() > 0)
{
foreach (Tweetinvi.Models.V2.UserMentionV2 mention in args.Tweet.Entities.Mentions)
{
List <SQLiteParameter> InnerParamList = new List <SQLiteParameter>
{
dao.NewParameter("name", mention.Username)
};
string text = "INSERT INTO mentions(name) VALUES(@name)";
dao.RunSQLiteCommand(text, InnerParamList);
}
}
}
List <SQLiteParameter> ParamList = new List <SQLiteParameter>
{
dao.NewParameter("text", args.Tweet.Text),
dao.NewParameter("date", args.Tweet.CreatedAt.ToUnixTimeSeconds()),
dao.NewParameter("lang", args.Tweet.Lang),
dao.NewParameter("source", args.Tweet.Source),
dao.NewParameter("like", args.Tweet.PublicMetrics.LikeCount),
dao.NewParameter("retweet", args.Tweet.PublicMetrics.RetweetCount),
dao.NewParameter("hasUrl", hasUrl),
dao.NewParameter("hasImage", hasImage),
dao.NewParameter("hasEmoji", hasEmoji)
};
string CommandText = "INSERT INTO tweets(text, date, lang, source, like, retweet, hasUrl, hasImage, hasEmoji) VALUES(@text, @date, @lang, @source, @like, @reTweet, @hasUrl, @hasImage, @hasEmoji)";
dao.RunSQLiteCommand(CommandText, ParamList);
};
await sampleStreamV2.StartAsync();
}
