public TweetController(IHttpClientFactory clientFactory, ILogger <TweetController> logger,
IOptions <TwitterOptions> options)
{
this.clientFactory = clientFactory;
this.logger = logger;
twitterConf = options.Value;
}
public SubscriptionsService(
ITwitterClient twitterClient,
TwitterOptions twitterOptions)
{
_twitterClient = twitterClient;
_twitterOptions = twitterOptions;
}
public void Configure(string name, TwitterOptions options)
{
if (!string.Equals(name, TwitterDefaults.AuthenticationScheme))
{
return;
}
var settings = GetSettingsAsync().GetAwaiter().GetResult();
options.ConsumerKey = settings.Item1?.ConsumerKey ?? string.Empty;
try
{
options.ConsumerSecret = _dataProtectionProvider.CreateProtector(TwitterConstants.Features.Twitter).Unprotect(settings.Item1.ConsumerSecret);
}
catch
{
_logger.LogError("The Consumer Secret could not be decrypted. It may have been encrypted using a different key.");
}
if (settings.Item2.CallbackPath.HasValue)
{
options.CallbackPath = settings.Item2.CallbackPath;
}
options.RetrieveUserDetails = true;
options.SignInScheme = "Identity.External";
options.StateCookie.Path = _tenantPrefix;
}
void ConfigureTwitterAuthOptions(TwitterOptions opts)
{
opts.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
opts.ConsumerKey = _config["Twitter:ConsumerKey"];
opts.ConsumerSecret = _config["Twitter:ConsumerSecret"];
opts.RetrieveUserDetails = true;
}
static Dictionary <string, string> GetParms(string nonce, string timestamp, TwitterOptions options, bool callBack, bool imageUpload)
{
Dictionary <string, string> dic = new Dictionary <string, string>();
if (callBack)
{
dic.Add("oauth_callback", "oob");
}
dic.Add(OAUTH_CONSUMER_KEY, Util.EncodeString(options.User.AppSettings.AppKey));
dic.Add(OAUTH_NONCE, nonce);
dic.Add(OAUTH_SIGNATURE_METHOD, HMAC_SHA1);
dic.Add(OAUTH_TIMESTAMP, timestamp);
dic.Add(OAUTH_VERSION, OAUTH_VERSION_10);
dic.Add(OAUTH_TOKEN, options.User.OAuthToken);
if (!imageUpload)
{
foreach (var item in options.GetParameters())
{
dic.Add(item.Key, item.Value);
}
}
return(dic);
}
public WebhooksService(
ITwitterClient twitterClient,
TwitterOptions twitterOptions)
{
_twitterClient = twitterClient;
_twitterOptions = twitterOptions;
}
private void SetTwitterOptions(TwitterOptions options)
{
options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
options.ConsumerKey = "key";
options.ConsumerSecret = "secret";
}
public BaseController(IOptions <TwitterOptions> twitterOptions)
{
if (twitterOptions is null)
{
throw new ArgumentNullException(nameof(twitterOptions));
}
_twitterOptions = twitterOptions.Value;
}
public WebhookMiddleware(IOptions <TwitterOptions> options, ILogger <WebhookMiddleware> logger, IBot bot,
TwitterAdapter adapter)
{
_logger = logger;
_bot = bot;
_adapter = adapter;
_options = options.Value;
_interceptor = new WebhookInterceptor(_options.ConsumerSecret);
}
public UIController(ICommandBus commandBus,
IOptions <MyUIOptions> uiOptions,
IOptions <TwitterOptions> twitterOptions,
IGrainFactory grainFactory)
: base(commandBus)
{
this.uiOptions = uiOptions.Value;
this.grainFactory = grainFactory;
this.twitterOptions = twitterOptions.Value;
}
public static IApplicationBuilder UseTwitterAuthentication([NotNull] this IApplicationBuilder app, Action <TwitterOptions> configureOptions = null)
{
var options = new TwitterOptions();
if (configureOptions != null)
{
configureOptions(options);
}
return(app.UseTwitterAuthentication(options));
}
public async Task <RetrieveTweetsResult> RetrieveTweetsAsync(TwitterOptions options, string key)
{
var result = new RetrieveTweetsResult();
var tweetList = new List <TweetStruct>();
if (!string.IsNullOrEmpty(options.Username) && !string.IsNullOrEmpty(options.TwitterConsumerKey) && !string.IsNullOrEmpty(options.TwitterConsumerSecret))
{
var bearerToken = ObtainBearerToken(options.TwitterConsumerKey, options.TwitterConsumerSecret);
var timelineUrl = string.Format("https://api.twitter.com/1.1/statuses/user_timeline.json?exclude_replies={0}&screen_name={1}", !options.ShowReplies ? "true" : "false", Uri.EscapeDataString(options.Username));
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(timelineUrl);
request.Headers.Add("Authorization", "Bearer " + bearerToken);
request.Method = "GET";
request.ContentType = "application/x-www-form-urlencoded;charset=UTF-8";
request.AutomaticDecompression = DecompressionMethods.GZip;
WebResponse response = await request.GetResponseAsync();
string responseData = await new StreamReader(response.GetResponseStream()).ReadToEndAsync();
var fromJsonArray = JsonConvert.DeserializeObject <IEnumerable <TwitterJson> >(responseData);
string[] hashtagFilter = null;
if (!string.IsNullOrEmpty(options.HashTagsFilter))
{
hashtagFilter = options.HashTagsFilter.Split(',');
}
var tweets = from tweet in fromJsonArray
where
// Hashtags
(hashtagFilter == null || (hashtagFilter != null && hashtagFilter.Any(p => tweet.text.Contains(p))))
&&
// Show replies
(options.ShowReplies || String.IsNullOrEmpty(tweet.in_reply_to_screen_name))
select new TweetStruct()
{
Message = tweet.text,
Username = tweet.user.screen_name,
Avatar = tweet.user.profile_image_url,
Timestamp = (DateTime.ParseExact(tweet.created_at, "ddd MMM dd HH:mm:ss %zzzz yyyy", CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal)).ToFriendlyDate(),
Id = tweet.id_str
};
tweetList.AddRange(tweets.Take(options.Count > 0 ? options.Count : 10));
}
result.Tweets = tweetList;
result.DateTimeExecuted = DateTime.Now;
result.IsSuccessful = true;
result.Settings = options;
return(result);
}
public MultiTenantTwitterOptionsResolver(
TwitterOptions originalOptions,
ISiteResolver siteResolver,
ISiteRepository siteRepository,
MultiTenantOptions multiTenantOptions)
{
this.originalOptions = originalOptions;
this.siteResolver = siteResolver;
this.multiTenantOptions = multiTenantOptions;
siteRepo = siteRepository;
}
public MultiTenantTwitterOptionsResolver(
TwitterOptions originalOptions,
ISiteSettings currentSite,
MultiTenantOptions multiTenantOptions)
{
this.originalOptions = originalOptions;
//this.siteResolver = siteResolver;
site = currentSite;
this.multiTenantOptions = multiTenantOptions;
//siteRepo = siteRepository;
}
public static void CheckData(TwitterOptions options)
{
if (options.User == null)
{
throw new Exception("NO USER");
}
if (options.User.AppSettings == null)
{
throw new Exception("NO APPLICATION");
}
}
public TwitterClient(
IHttpClientFactory httpClientFactory,
TwitterOptions twitterOptions)
{
_httpClient = httpClientFactory.CreateClient();
_twitterOptions = twitterOptions;
_httpClient.BaseAddress = new Uri(twitterOptions.TwitterApiUrl);
_sigHasher = new HMACSHA1(new ASCIIEncoding().GetBytes($"{_twitterOptions.ConsumerSecret}&{_twitterOptions.AccessTokenSecret}"));
_httpClient.BaseAddress = new Uri(_twitterOptions.TwitterApiUrl);
}
void ConfigTwitterAuthentication(TwitterOptions options,
Dictionary <string, string> claims)
{
var clientIdKey = "Twitter:ClientId";
var ClientSecretKey = "Twitter:ClientSecret";
if (claims.ContainsKey(clientIdKey) &&
claims.ContainsKey(ClientSecretKey))
{
options.ConsumerKey = claims[clientIdKey];
options.ConsumerSecret = claims[ClientSecretKey];
}
}
public async Task AddAsync_should_add_twitter_handler()
{
var eventCalled = false;
Task onTicketReceived(TicketReceivedContext context)
{
eventCalled = true;
return(Task.CompletedTask);
}
var provider = CreateServiceProvider(options =>
{
options.AddTwitter(configure =>
{
configure.Events.OnTicketReceived = onTicketReceived;
});
});
var twittertOptions = new TwitterOptions
{
ConsumerKey = "test",
ConsumerSecret = "test"
};
var scheme = Guid.NewGuid().ToString();
var definition = new TSchemeDefinition
{
Scheme = scheme,
DisplayName = "test",
HandlerType = typeof(TwitterHandler),
Options = twittertOptions
};
var sut = provider.GetRequiredService <AuthenticationSchemeProviderWrapper>();
Assert.Contains(typeof(TwitterHandler), sut.GetManagedHandlerTypes());
await sut.AddAsync(definition);
var state = await VerifyAddedAsync <TwitterOptions>(scheme, provider);
var httpContext = new Mock <HttpContext>().Object;
state.options.Events.OnTicketReceived(new TicketReceivedContext(
httpContext,
state.scheme as AuthenticationScheme,
state.options as TwitterOptions,
new AuthenticationTicket(new ClaimsPrincipal(), "test")));
Assert.True(eventCalled);
}
public WebhookHostedService(
IApplicationLifetime applicationLifetime,
IOptions <TwitterOptions> options,
ILogger <WebhookHostedService> logger)
{
_logger = logger;
_options = options.Value;
_webhooksManager = new WebhooksPremiumManager(_options);
_subscriptionsManager = new SubscriptionsManager(_options);
// Initialize logic after host has started, to ensure WebhookMiddleware
// is available for webhook registration
applicationLifetime.ApplicationStarted.Register(InitializeWebhookAsync);
}
public TenantMiddleware(
RequestDelegate next,
TenantService tenantService,
IAuthenticationSchemeProvider oauthProvider,
IMemoryCache memoryCache,
IdentityServerOptions identityServerOptions,
IOptionsMonitor <AmazonAuthenticationOptions> amazonOptions,
IOptionsMonitor <FacebookOptions> facebookOptions,
IOptionsMonitor <GitHubOptions> githubOptions,
IOptionsMonitor <GitterAuthenticationOptions> gitterOptions,
IOptionsMonitor <GoogleOptions> googleOptions,
IOptionsMonitor <InstagramAuthenticationOptions> instagramOptions,
IOptionsMonitor <LinkedInAuthenticationOptions> linkedinOptions,
IOptionsMonitor <MicrosoftAccountOptions> microsoftOptions,
IOptionsMonitor <PaypalAuthenticationOptions> paypalOptions,
IOptionsMonitor <QQOptions> qqOptions,
IOptionsMonitor <RedditAuthenticationOptions> redditOptions,
IOptionsMonitor <SalesforceAuthenticationOptions> salesforceOptions,
IOptionsMonitor <TwitterOptions> twitterOptions,
IOptionsMonitor <VisualStudioAuthenticationOptions> visualstudioOptions,
IOptionsMonitor <WeiboOptions> weiboOptions,
IOptionsMonitor <WeixinOptions> weixinOptions,
IOptionsMonitor <WordPressAuthenticationOptions> wordpressOptions
)
{
_next = next;
_tenantService = tenantService;
_oauthProvider = oauthProvider;
_memoryCache = memoryCache;
_identityServerOptions = identityServerOptions;
_amazonOptions = amazonOptions.CurrentValue;
_facebookOptions = facebookOptions.CurrentValue;
_githubOptions = githubOptions.CurrentValue;
_gitterOptions = gitterOptions.CurrentValue;
_googleOptions = googleOptions.CurrentValue;
_instagramOptions = instagramOptions.CurrentValue;
_linkedinOptions = linkedinOptions.CurrentValue;
_microsoftOptions = microsoftOptions.CurrentValue;
_paypalOptions = paypalOptions.CurrentValue;
_qqOptions = qqOptions.CurrentValue;
_redditOptions = redditOptions.CurrentValue;
_salesforceOptions = salesforceOptions.CurrentValue;
_twitterOptions = twitterOptions.CurrentValue;
_visualstudioOptions = visualstudioOptions.CurrentValue;
_weiboOptions = weiboOptions.CurrentValue;
_weixinOptions = weixinOptions.CurrentValue;
_wordpressOptions = wordpressOptions.CurrentValue;
}
public RetrieveTweetsViewComponent(ITwitterService twitterService, ILogger <RetrieveTweetsViewComponent> logger, TwitterCache cache, IOptions <TwitterOptions> options = null)
{
TwitterService = twitterService;
Log = logger;
Cache = cache;
if (options != null)
{
TwitterOptions = options.Value;
}
else
{
TwitterOptions = new TwitterOptions();
}
}
/// <summary>
/// Adds the <see cref="TwitterMiddleware"/> middleware to the specified <see cref="IApplicationBuilder"/>, which enables Twitter authentication capabilities.
/// </summary>
/// <param name="app">The <see cref="IApplicationBuilder"/> to add the middleware to.</param>
/// <param name="configureOptions">An action delegate to configure the provided <see cref="TwitterOptions"/>.</param>
/// <returns>A reference to this instance after the operation has completed.</returns>
public static IApplicationBuilder UseTwitterAuthentication(this IApplicationBuilder app, Action <TwitterOptions> configureOptions = null)
{
if (app == null)
{
throw new ArgumentNullException(nameof(app));
}
var options = new TwitterOptions();
if (configureOptions != null)
{
configureOptions(options);
}
return(app.UseTwitterAuthentication(options));
}
public TwitterCacheWrapperService(ITwitterService twitterService, ILogger logger, TwitterCache cache, TwitterOptions options = null)
{
TwitterService = twitterService;
Log = logger;
_cache = cache.Cache;
if (options != null)
{
TwitterOptions = options;
}
else
{
TwitterOptions = new TwitterOptions();
}
}
public TwitterWidgetController(ITwitterService twitterService, ILogger <TwitterWidgetController> logger, TwitterCache cache, IOptions <TwitterOptions> options = null)
{
TwitterService = twitterService;
Log = logger;
Cache = cache;
if (options != null)
{
TwitterOptions = options.Value;
}
else
{
TwitterOptions = new TwitterOptions();
}
}
public static IApplicationBuilder UseMultiTenantTwitterAuthentication(
this IApplicationBuilder app,
Action <TwitterOptions> configureOptions)
{
//https://github.com/aspnet/Security/blob/582f562bbb20fc76f37023086e2b2d861eb4d43d/src/Microsoft.AspNet.Authentication.Twitter/TwitterOptions.cs
var options = new TwitterOptions();
if (configureOptions != null)
{
configureOptions(options);
}
return(app.UseMiddleware <MultiTenantTwitterMiddleware>(options));
}
public void Configure(string name, TwitterOptions options)
{
if (!string.Equals(name, TwitterDefaults.AuthenticationScheme, StringComparison.Ordinal))
{
return;
}
if (!ValidSettings())
{
return;
}
options.ConsumerKey = _platoTwitterOptions.ConsumerKey;
options.ConsumerSecret = _platoTwitterOptions.ConsumerSecret;
if (_platoTwitterOptions.CallbackPath.HasValue)
{
options.CallbackPath = _platoTwitterOptions.CallbackPath;
}
}
internal static HttpRequestMessage GetRequest(HttpMethod method, string baseUrl, TwitterOptions options, bool callBack, bool imageUpload)
{
//OAuthAuthenticator.Current.OnAuthenticationNeeded();
string url = baseUrl;
if (method == HttpMethod.Get)
{
url = $"{baseUrl}?{options.GetUrlParameters()}";
if (url.EndsWith("?"))
{
url = url.Substring(0, url.Length - 1);
}
}
string nonce = GetNonce();
string timestamp = GetTimestamp();
Dictionary <string, string> parms = GetParms(nonce, timestamp, options, callBack, imageUpload);
string signatureBase = SignatureBsseString(method.Method, baseUrl, parms);
string signature = OAuthAuthenticator.SignBaseString(signatureBase, options.User.OAuthTokenSecret, options.User.AppSettings.AppSecret);
string authHeader = OAuthAuthenticator.AuthorizationHeader(nonce, signature, timestamp, options.User.OAuthToken, callBack, string.Empty, options.User.AppSettings.AppKey);
HttpRequestMessage reqMsg = new HttpRequestMessage(method, url);
reqMsg.Headers.Add(Constants.HEADERS.AUTHORIZATION, authHeader);
return(reqMsg);
}
// Configure is called after ConfigureServices is called.
public async void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, SampleDataGenerator sampleData, AllReadyContext context, IConfiguration configuration)
{
// Put first to avoid issues with OPTIONS when calling from Angular/Browser.
app.UseCors("allReady");
// todo: in RC update we can read from a logging.json config file
loggerFactory.AddConsole((category, level) =>
{
if (category.StartsWith("Microsoft."))
{
return(level >= LogLevel.Information);
}
return(true);
});
if (env.IsDevelopment())
{
// this will go to the VS output window
loggerFactory.AddDebug((category, level) =>
{
if (category.StartsWith("Microsoft."))
{
return(level >= LogLevel.Information);
}
return(true);
});
}
// Add Application Insights to the request pipeline to track HTTP request telemetry data.
app.UseApplicationInsightsRequestTelemetry();
// Add the following to the request pipeline only in development environment.
if (env.IsDevelopment())
{
app.UseBrowserLink();
app.UseDeveloperExceptionPage();
app.UseDatabaseErrorPage();
}
else if (env.IsStaging())
{
app.UseDeveloperExceptionPage();
app.UseDatabaseErrorPage();
}
else
{
// Add Error handling middleware which catches all application specific errors and
// sends the request to the following path or controller action.
app.UseExceptionHandler("/Home/Error");
}
// Track data about exceptions from the application. Should be configured after all error handling middleware in the request pipeline.
app.UseApplicationInsightsExceptionTelemetry();
// Add static files to the request pipeline.
app.UseStaticFiles();
app.UseRequestLocalization();
// Add cookie-based authentication to the request pipeline.
app.UseIdentity();
// Add token-based protection to the request inject pipeline
app.UseTokenProtection(new TokenProtectedResourceOptions
{
Path = "/api/request",
PolicyName = "api-request-injest"
});
// Add authentication middleware to the request pipeline. You can configure options such as Id and Secret in the ConfigureServices method.
// For more information see http://go.microsoft.com/fwlink/?LinkID=532715
if (Configuration["Authentication:Facebook:AppId"] != null)
{
var options = new FacebookOptions
{
AppId = Configuration["Authentication:Facebook:AppId"],
AppSecret = Configuration["Authentication:Facebook:AppSecret"],
BackchannelHttpHandler = new FacebookBackChannelHandler(),
UserInformationEndpoint = "https://graph.facebook.com/v2.5/me?fields=id,name,email,first_name,last_name"
};
options.Scope.Add("email");
app.UseFacebookAuthentication(options);
}
if (Configuration["Authentication:MicrosoftAccount:ClientId"] != null)
{
var options = new MicrosoftAccountOptions
{
ClientId = Configuration["Authentication:MicrosoftAccount:ClientId"],
ClientSecret = Configuration["Authentication:MicrosoftAccount:ClientSecret"]
};
app.UseMicrosoftAccountAuthentication(options);
}
//http://www.bigbrainintelligence.com/Post/get-users-email-address-from-twitter-oauth-ap
if (Configuration["Authentication:Twitter:ConsumerKey"] != null)
{
var options = new TwitterOptions
{
ConsumerKey = Configuration["Authentication:Twitter:ConsumerKey"],
ConsumerSecret = Configuration["Authentication:Twitter:ConsumerSecret"]
};
app.UseTwitterAuthentication(options);
}
if (Configuration["Authentication:Google:ClientId"] != null)
{
var options = new GoogleOptions
{
ClientId = Configuration["Authentication:Google:ClientId"],
ClientSecret = Configuration["Authentication:Google:ClientSecret"]
};
app.UseGoogleAuthentication(options);
}
//call Migrate here to force the creation of the AllReady database so Hangfire can create its schema under it
if (!env.IsProduction())
{
context.Database.Migrate();
}
//Hangfire
app.UseHangfireDashboard("/hangfire", new DashboardOptions {
Authorization = new[] { new HangireDashboardAuthorizationFilter() }
});
app.UseHangfireServer();
// Add MVC to the request pipeline.
app.UseMvc(routes =>
{
routes.MapRoute(name: "areaRoute", template: "{area:exists}/{controller}/{action=Index}/{id?}");
routes.MapRoute(name: "default", template: "{controller=Home}/{action=Index}/{id?}");
});
// Add sample data and test admin accounts if specified in Config.Json.
// for production applications, this should either be set to false or deleted.
if (Configuration["SampleData:InsertSampleData"] == "true")
{
sampleData.InsertTestData();
}
if (Configuration["SampleData:InsertTestUsers"] == "true")
{
await sampleData.CreateAdminUser();
}
}
public DirectMessageSender(TwitterOptions context)
{
Options = context;
}
/// <summary>
/// Returns a ready 'OAuth ..' prefixed header to set in any call to Twitter API.
/// </summary>
/// <param name="options">Twitter app auth context.</param>
/// <param name="method">The Request Http method.</param>
/// <param name="requestUrl">The Request uri along with any query parameter.</param>
/// <returns></returns>
public static string Build(TwitterOptions options, HttpMethod method, string requestUrl)
{
if (!Uri.TryCreate(requestUrl, UriKind.RelativeOrAbsolute, out var resourceUri))
{
throw new TwitterException("Invalid Resource Url format.");
}
if (options == null || !options.IsValid)
{
throw new TwitterException("Invalid Twitter options.");
}
const string oauthVersion = "1.0";
const string oauthSignatureMethod = "HMAC-SHA1";
// It could be any random string..
var oauthNonce = DateTime.Now.Ticks.ToString();
var epochTimeStamp =
(DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc)).TotalSeconds;
var oauthTimestamp = Convert.ToInt64(epochTimeStamp).ToString();
var signatureParams = new Dictionary <string, string>
{
{ "oauth_consumer_key", options.ConsumerKey },
{ "oauth_nonce", oauthNonce },
{ "oauth_signature_method", oauthSignatureMethod },
{ "oauth_timestamp", oauthTimestamp },
{ "oauth_token", options.AccessToken },
{ "oauth_version", oauthVersion }
};
var qParams = resourceUri.GetParams();
foreach (var qp in qParams)
{
signatureParams.Add(qp.Key, qp.Value);
}
var baseString = string.Join("&",
signatureParams.OrderBy(kpv => kpv.Key).Select(kpv => $"{kpv.Key}={kpv.Value}"));
var resourceUrl = requestUrl.Contains("?")
? requestUrl.Substring(0, requestUrl.IndexOf("?", StringComparison.Ordinal))
: requestUrl;
baseString = string.Concat(method.Method.ToUpper(), "&", Uri.EscapeDataString(resourceUrl), "&",
Uri.EscapeDataString(baseString));
var oauthSignatureKey = string.Concat(Uri.EscapeDataString(options.ConsumerSecret), "&",
Uri.EscapeDataString(options.AccessSecret));
string oauthSignature;
using (var hasher = new HMACSHA1(Encoding.ASCII.GetBytes(oauthSignatureKey)))
{
oauthSignature = Convert.ToBase64String(hasher.ComputeHash(Encoding.ASCII.GetBytes(baseString)));
}
const string headerFormat = "OAuth oauth_nonce=\"{0}\", oauth_signature_method=\"{1}\", " +
"oauth_timestamp=\"{2}\", oauth_consumer_key=\"{3}\", " +
"oauth_token=\"{4}\", oauth_signature=\"{5}\", " +
"oauth_version=\"{6}\"";
return(string.Format(headerFormat,
Uri.EscapeDataString(oauthNonce),
Uri.EscapeDataString(oauthSignatureMethod),
Uri.EscapeDataString(oauthTimestamp),
Uri.EscapeDataString(options.ConsumerKey),
Uri.EscapeDataString(options.AccessToken),
Uri.EscapeDataString(oauthSignature),
Uri.EscapeDataString(oauthVersion)));
}