public void ConfigureAuth(IAppBuilder app)
{
app.CreatePerOwinContext(WebAppContainer.Container.Resolve<UserManager<ApplicationUser>>);
app.UseCookieAuthentication(new CookieAuthenticationOptions
{
AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
LoginPath = new PathString("/Account/Login"),
Provider = new CookieAuthenticationProvider
{
OnValidateIdentity =
SecurityStampValidator.OnValidateIdentity<UserManager<ApplicationUser>, ApplicationUser>(TimeSpan.FromMinutes(30),
(manager, user) => user.GenerateUserIdentityAsync(manager))
}
});
app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);
app.UseOAuthBearerTokens(OAuthOptions);
var gitHubOptions = new GitHubAuthenticationOptions
{
ClientId = CloudConfigurationManager.GetSetting("GitHub.ClientId"),
ClientSecret = CloudConfigurationManager.GetSetting("GitHub.ClientSecret"),
};
app.UseGitHubAuthentication(gitHubOptions);
}
// For more information on configuring authentication, please visit http://go.microsoft.com/fwlink/?LinkId=301864
public void ConfigureAuth(IAppBuilder app)
{
app.SetDefaultSignInAsAuthenticationType("ExternalCookie");
app.UseCookieAuthentication(new CookieAuthenticationOptions
{
AuthenticationType = "ExternalCookie",
AuthenticationMode = AuthenticationMode.Passive,
CookieName = ".AspNet.ExternalCookie",
ExpireTimeSpan = TimeSpan.FromMinutes(5),
});
var options = new GitHubAuthenticationOptions
{
ClientId = ConfigurationManager.AppSettings["ClientId"],
ClientSecret = ConfigurationManager.AppSettings["ClientSecret"],
Provider = new GitHubAuthenticationProvider
{
OnAuthenticated = context =>
{
context.Identity.AddClaim(new Claim("urn:github:token", context.AccessToken));
context.Identity.AddClaim(new Claim("urn:github:username", context.UserName));
return Task.FromResult(true);
}
}
};
options.Scope.Add("user:email");
options.Scope.Add("repo");
app.UseGitHubAuthentication(options);
}
public void Configuration(IAppBuilder app)
{
app.SetDefaultSignInAsAuthenticationType("ExternalCookie");
app.UseCookieAuthentication(new CookieAuthenticationOptions
{
AuthenticationType = "ExternalCookie",
AuthenticationMode = AuthenticationMode.Passive,
CookieName = ".AspNet.ExternalCookie",
ExpireTimeSpan = TimeSpan.FromMinutes(5),
});
var options = new GitHubAuthenticationOptions
{
ClientId = "your cliend in",
ClientSecret = "your client secret",
Provider = new GitHubAuthenticationProvider
{
OnAuthenticated = context =>
{
context.Identity.AddClaim(new Claim("urn:token:github", context.AccessToken));
return Task.FromResult(true);
}
}
};
app.UseGitHubAuthentication(options);
app.MapSignalR();
}
public static IAppBuilder UseGitHubAuthentication(this IAppBuilder app,
GitHubAuthenticationOptions options)
{
if (app == null)
throw new ArgumentNullException("app");
if (options == null)
throw new ArgumentNullException("options");
app.Use(typeof(GitHubAuthenticationMiddleware), app, options);
return app;
}
public void Configuration(IAppBuilder application)
{
application.SetDefaultSignInAsAuthenticationType(DefaultAuthenticationTypes.ApplicationCookie);
application.UseCookieAuthentication(new CookieAuthenticationOptions()
{
AuthenticationMode = AuthenticationMode.Active,
AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
LoginPath = new PathString("/"),
});
var options = new GitHubAuthenticationOptions()
{
AuthenticationMode = AuthenticationMode.Active,
AuthenticationType = "GitHub",
SignInAsAuthenticationType = application.GetDefaultSignInAsAuthenticationType(),
ClientId = ConfigurationManager.AppSettings["clientId"],
ClientSecret = ConfigurationManager.AppSettings["clientSecret"],
Provider = new GitHubAuthenticationProvider
{
OnAuthenticated = context =>
{
context.Identity.AddClaim(new Claim("urn:github:avatar_url", context.User["avatar_url"].ToString()));
context.Identity.AddClaim(new Claim("urn:github:acess_token", context.AccessToken));
return Task.FromResult(0);
}
}
};
options.Scope.Clear();
application.UseGitHubAuthentication(options);
var builder = new ContainerBuilder();
builder.RegisterHubs(Assembly.GetExecutingAssembly());
var container = builder.Build();
application.Map("/signalr", map =>
{
map.UseCors(CorsOptions.AllowAll);
var hubConfiguration = new HubConfiguration()
{
Resolver = new AutofacDependencyResolver(container)
};
map.RunSignalR(hubConfiguration);
}).UseNancy(new NancyOptions()
{
Bootstrapper = new Bootstrapper(container)
});
}
// For more information on configuring authentication, please visit http://go.microsoft.com/fwlink/?LinkId=301864
public void ConfigureAuth(IAppBuilder app)
{
// Configure the db context, user manager and signin manager to use a single instance per request
app.CreatePerOwinContext(SiteDbContext.Create);
app.CreatePerOwinContext<ApplicationUserManager>(ApplicationUserManager.Create);
app.CreatePerOwinContext<ApplicationSignInManager>(ApplicationSignInManager.Create);
// Enable the application to use a cookie to store information for the signed in user
// and to use a cookie to temporarily store information about a user logging in with a third party login provider
// Configure the sign in cookie
app.UseCookieAuthentication(new CookieAuthenticationOptions
{
AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
LoginPath = new PathString("/Account/Login"),
Provider = new CookieAuthenticationProvider
{
// Enables the application to validate the security stamp when the user logs in.
// This is a security feature which is used when you change a password or add an external login to your account.
OnValidateIdentity =
SecurityStampValidator.OnValidateIdentity<ApplicationUserManager, ApplicationUser>(
TimeSpan.FromMinutes(30), (manager, user) => user.GenerateUserIdentityAsync(manager))
}
});
app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);
// Enables the application to temporarily store user information when they are verifying the second factor in the two-factor authentication process.
app.UseTwoFactorSignInCookie(DefaultAuthenticationTypes.TwoFactorCookie, TimeSpan.FromMinutes(5));
// Enables the application to remember the second login verification factor such as phone or email.
// Once you check this option, your second step of verification during the login process will be remembered on the device where you logged in from.
// This is similar to the RememberMe option when you log in.
app.UseTwoFactorRememberBrowserCookie(DefaultAuthenticationTypes.TwoFactorRememberBrowserCookie);
// If we are in debug mode, return
if (DebugExtensions.IsDebug()) return;
/*
The Following Code will not be run in Debug mode
*/
// Setup Github
var options = new GitHubAuthenticationOptions
{
ClientId = ConfigurationManager.AppSettings["GitHubClientId"],
ClientSecret = ConfigurationManager.AppSettings["GitHubSecret"]
};
// Register GitHub Auth
app.UseGitHubAuthentication(options);
}
public static void ConfigureAdditionalIdentityProviders2(IAppBuilder app, string signInAsType)
{
var gitHub = new GitHubAuthenticationOptions
{
AuthenticationType = "GitHub",
SignInAsAuthenticationType = signInAsType,
ClientId = "XXXXXXXXX",
ClientSecret = "XXXXXXXXX",
};
app.UseGitHubAuthentication(gitHub);
var fb = new FacebookAuthenticationOptions
{
AuthenticationType = "Facebook",
SignInAsAuthenticationType = signInAsType,
AppId = "XXXXXXXXX",
AppSecret = "XXXXXXXXX",
Scope = {"email"}
};
app.UseFacebookAuthentication(fb);
var google = new GoogleOAuth2AuthenticationOptions
{
AuthenticationType = "Google",
SignInAsAuthenticationType = signInAsType,
ClientId = "XXXXXXXXX",
ClientSecret = "XXXXXXXXX",
Scope = {"email"}
};
app.UseGoogleAuthentication(google);
var cosign2 = new CosignAuthenticationOptions
{
AuthenticationType = "Cosign",
SignInAsAuthenticationType = signInAsType,
CosignServer = "weblogin.umich.edu",
CosignServicePort = 6663,
IdentityServerHostInstance = "core2",
#if DEBUG
ClientServer = "devservername"
#else
ClientServer = "prodservernameu"
#endif
};
app.UseCosignAuthentication(cosign2);
}
public void ConfigureOAuth(IAppBuilder app)
{
app.CreatePerOwinContext(DBContext.Create);
app.CreatePerOwinContext<ApplicationUserManager>(ApplicationUserManager.Create);
app.CreatePerOwinContext<ApplicationRoleManager>(ApplicationRoleManager.Create);
//app.CreatePerOwinContext<ApplicationSignInManager>(ApplicationSignInManager.Create);
//use a cookie to temporarily store information about a user logging in with a third party login provider
app.UseExternalSignInCookie(Microsoft.AspNet.Identity.DefaultAuthenticationTypes.ExternalCookie);
OAuthBearerOptions = new OAuthBearerAuthenticationOptions();
OAuthAuthorizationServerOptions OAuthServerOptions = new OAuthAuthorizationServerOptions()
{
AllowInsecureHttp = true,
TokenEndpointPath = new PathString("/token"),
AccessTokenExpireTimeSpan = TimeSpan.FromDays(1),
Provider = new SimpleAuthorizationServerProvider(),
RefreshTokenProvider = new SimpleRefreshTokenProvider()
};
// Token Generation
app.UseOAuthAuthorizationServer(OAuthServerOptions);
app.UseOAuthBearerAuthentication(OAuthBearerOptions);
//Configure Google External Login
googleAuthOptions = new GooglePlusAuthenticationOptions()
{
ClientId = ConfigurationManager.AppSettings["GooglePlusClientId"],
ClientSecret = ConfigurationManager.AppSettings["GooglePlusClientSecret"],
Provider = new GoogleAuthProvider(),
CallbackPath = new PathString("/signin-googleplus")
};
// TODO uncomment to use G+ auth
app.UseGooglePlusAuthentication(googleAuthOptions);
string stripeClientId = ConfigurationManager.AppSettings["StripeClientId"];
string stripeClientSecret = ConfigurationManager.AppSettings["StripeClientSecret"];
stripeAuthOptions = new StripeAuthenticationOptions()
{
ClientId = stripeClientId,
ClientSecret = stripeClientSecret,
Provider = new StripeAuthProvider()
{
OnAuthenticated = async context =>
{
context.Identity.AddClaim(new Claim("ExternalAccessToken", context.AccessToken));
context.Identity.AddClaim(new Claim("urn:stripe:refreshToken", context.RefreshToken));
}
},
SignInAsAuthenticationType = Microsoft.AspNet.Identity.DefaultAuthenticationTypes.ExternalCookie
};
app.UseStripeAuthentication(stripeAuthOptions);
string linkedinApiKey = ConfigurationManager.AppSettings["LinkedInApiKey"];
string linkedinSecret = ConfigurationManager.AppSettings["LinkedInSecret"];
linkedinAuthOptions = new LinkedInAuthenticationOptions()
{
ClientId = linkedinApiKey,
ClientSecret = linkedinSecret,
Provider = new LinkedInAuthProvider
{
OnAuthenticated = async context =>
{
context.Identity.AddClaim(new Claim("ExternalAccessToken", context.AccessToken));
}
},
SignInAsAuthenticationType = DefaultAuthenticationTypes.ExternalCookie
};
app.UseLinkedInAuthentication(linkedinAuthOptions);
string githubClientId = ConfigurationManager.AppSettings["GithubClientId"];
string githubClientSecret = ConfigurationManager.AppSettings["GithubClientSecret"];
githubAuthOptions = new GitHubAuthenticationOptions()
{
ClientId = githubClientId,
ClientSecret = githubClientSecret,
Provider = new GitHubAuthProvider
{
OnAuthenticated = async context =>
{
context.Identity.AddClaim(new Claim("ExternalAccessToken", context.AccessToken));
}
},
SignInAsAuthenticationType = DefaultAuthenticationTypes.ExternalCookie
};
app.UseGitHubAuthentication(githubAuthOptions);
string twitterConsumerKey = ConfigurationManager.AppSettings["TwitterConsumerKey"];
string twitterConsumerSecret = ConfigurationManager.AppSettings["TwitterConsumerSecret"];
twitterAuthOptions = new TwitterAuthenticationOptions()
{
ConsumerKey = githubClientId,
ConsumerSecret = githubClientSecret,
Provider = new TwitterAuthProvider
{
OnAuthenticated = async context =>
{
context.Identity.AddClaim(new Claim("ExternalAccessToken", context.AccessToken));
}
},
SignInAsAuthenticationType = DefaultAuthenticationTypes.ExternalCookie
};
app.UseTwitterAuthentication(twitterAuthOptions);
string stackexchangeClientId = ConfigurationManager.AppSettings["StackExchangeClientId"];
string stackexchangeClientSecret = ConfigurationManager.AppSettings["StackExchangeClientSecret"];
string stackexchangeKey = ConfigurationManager.AppSettings["StackExchangeKey"];
#if DEBUG
stackexchangeClientId = ConfigurationManager.AppSettings["StackExchangeClientIdDEBUG"];
stackexchangeClientSecret = ConfigurationManager.AppSettings["StackExchangeClientSecretDEBUG"];
stackexchangeKey = ConfigurationManager.AppSettings["StackExchangeKeyDEBUG"];
#endif
stackexchangeAuthOptions = new StackExchangeAuthenticationOptions()
{
ClientId = stackexchangeClientId,
ClientSecret = stackexchangeClientSecret,
Key = stackexchangeKey,
Provider = new StackExchangeAuthProvider
{
OnAuthenticated = async context =>
{
context.Identity.AddClaim(new Claim("ExternalAccessToken", context.AccessToken));
}
},
SignInAsAuthenticationType = DefaultAuthenticationTypes.ExternalCookie
};
app.UseStackExchangeAuthentication(stackexchangeAuthOptions);
//Configure Facebook External Login
//facebookAuthOptions = new FacebookAuthenticationOptions()
//{
// AppId = "xxx",
// AppSecret = "xxx",
// Provider = new FacebookAuthProvider()
//};
//app.UseFacebookAuthentication(facebookAuthOptions);
}
private static void ConfigureIdentityProviders(IAppBuilder app, string signInAsType)
{
var google = new GoogleOAuth2AuthenticationOptions
{
AuthenticationType = "Google",
SignInAsAuthenticationType = signInAsType,
ClientId = "767400843187-8boio83mb57ruogr9af9ut09fkg56b27.apps.googleusercontent.com",
ClientSecret = "5fWcBT0udKY7_b6E3gEiJlze"
};
app.UseGoogleAuthentication(google);
var fb = new FacebookAuthenticationOptions
{
AuthenticationType = "Facebook",
SignInAsAuthenticationType = signInAsType,
AppId = "676607329068058",
AppSecret = "9d6ab75f921942e61fb43a9b1fc25c63"
};
app.UseFacebookAuthentication(fb);
var twitter = new TwitterAuthenticationOptions
{
AuthenticationType = "Twitter",
SignInAsAuthenticationType = signInAsType,
ConsumerKey = "N8r8w7PIepwtZZwtH066kMlmq",
ConsumerSecret = "df15L2x6kNI50E4PYcHS0ImBQlcGIt6huET8gQN41VFpUCwNjM"
};
app.UseTwitterAuthentication(twitter);
var ms = new MicrosoftAccountAuthenticationOptions
{
AuthenticationType = "Microsoft",
SignInAsAuthenticationType = signInAsType,
ClientId = "N8r8w7PIe",
ClientSecret = "df15L2x6kNI50E"
};
app.UseMicrosoftAccountAuthentication(ms);
var github = new GitHubAuthenticationOptions()
{
AuthenticationType = "Github",
SignInAsAuthenticationType = signInAsType,
ClientId = "N8r8w7PIe",
ClientSecret = "df15L2x6kNI50E"
};
app.UseGitHubAuthentication(github);
}
// For more information on configuring authentication, please visit http://go.microsoft.com/fwlink/?LinkId=301864
public void ConfigureAuth(IAppBuilder app)
{
// Configure the db context, user manager and signin manager to use a single instance per request
app.CreatePerOwinContext(ApplicationDbContext.Create);
app.CreatePerOwinContext<ApplicationUserManager>(ApplicationUserManager.Create);
app.CreatePerOwinContext<ApplicationSignInManager>(ApplicationSignInManager.Create);
// Enable the application to use a cookie to store information for the signed in user
// and to use a cookie to temporarily store information about a user logging in with a third party login provider
// Configure the sign in cookie
app.UseCookieAuthentication(new CookieAuthenticationOptions
{
AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
LoginPath = new PathString("/Account/Login"),
Provider = new CookieAuthenticationProvider
{
// Enables the application to validate the security stamp when the user logs in.
// This is a security feature which is used when you change a password or add an external login to your account.
OnValidateIdentity = SecurityStampValidator.OnValidateIdentity<ApplicationUserManager, ApplicationUser>(
validateInterval: TimeSpan.FromMinutes(30),
regenerateIdentity: (manager, user) => user.GenerateUserIdentityAsync(manager))
}
});
app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);
// Enables the application to temporarily store user information when they are verifying the second factor in the two-factor authentication process.
app.UseTwoFactorSignInCookie(DefaultAuthenticationTypes.TwoFactorCookie, TimeSpan.FromMinutes(5));
// Enables the application to remember the second login verification factor such as phone or email.
// Once you check this option, your second step of verification during the login process will be remembered on the device where you logged in from.
// This is similar to the RememberMe option when you log in.
app.UseTwoFactorRememberBrowserCookie(DefaultAuthenticationTypes.TwoFactorRememberBrowserCookie);
// Uncomment the following lines to enable logging in with third party login providers
app.UseMicrosoftAccountAuthentication(
clientId: "000000004017611E",
clientSecret: "ZZWAiJv4M09I5a-E0LNFTElaE6Wnlv1I");
app.UseQQConnectAuthentication(
appId: "101270486", appSecret: "64389d48959c53bd718118c33ca6c8cb");
app.UseSinaAuthentication("1312244040", "f62c6ccb6395427926a4e7e8abdcfc04");
//app.UseGitHubAuthentication(
// clientId: "232ffa8d82ab115fb94b",
// clientSecret: "ea702bed4d519295e166bb9dda2fcebed441d546");
var options = new GitHubAuthenticationOptions
{
ClientId = "232ffa8d82ab115fb94b",
ClientSecret = "ea702bed4d519295e166bb9dda2fcebed441d546",
CallbackPath = new PathString("/oauth-redirect/github"),
Provider = new GitHubAuthenticationProvider
{
OnAuthenticated = async context =>
{
// Retrieve the OAuth access token to store for subsequent API calls
string accessToken = context.AccessToken;
// Retrieve the username
string gitHubUserName = context.UserName;
// Retrieve the user's email address
string gitHubEmailAddress = context.Email;
// You can even retrieve the full JSON-serialized user
var serializedUser = context.User;
context.Identity.AddClaim(new System.Security.Claims.Claim("GitHubAccessToken", context.AccessToken));
}
}
};
options.Scope.Add("user");
options.Scope.Add("repo");
options.Scope.Add("public_repo");
options.SignInAsAuthenticationType = DefaultAuthenticationTypes.ExternalCookie;
app.UseGitHubAuthentication(options);
//app.UseTwitterAuthentication(
// consumerKey: "",
// consumerSecret: "");
//app.UseFacebookAuthentication(
// appId: "",
// appSecret: "");
//app.UseGoogleAuthentication(new GoogleOAuth2AuthenticationOptions()
//{
// ClientId = "",
// ClientSecret = ""
//});
}
public void ConfigureAuth(IAppBuilder app)
{
app.CreatePerOwinContext(ApplicationDbContext.Create);
app.CreatePerOwinContext<ApplicationUserManager>(ApplicationUserManager.Create);
app.CreatePerOwinContext<ApplicationSignInManager>(ApplicationSignInManager.Create);
//// Enable the application to use a cookie to store information for the signed in user
app.UseCookieAuthentication(new CookieAuthenticationOptions
{
AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
LoginPath = new PathString("/Account/Login"),
Provider = new CookieAuthenticationProvider
{
// Enables the application to validate the security stamp when the user logs in.
// This is a security feature which is used when you change a password or add an external login to your account.
OnValidateIdentity = SecurityStampValidator.OnValidateIdentity<ApplicationUserManager, ApplicationUser>(
validateInterval: TimeSpan.FromMinutes(20),
regenerateIdentity: (manager, user) => user.GenerateUserIdentityAsync(manager))
}
});
// Use a cookie to temporarily store information about a user logging in with a third party login provider
app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);
app.UseOAuthBearerTokens(OAuthOptions);
var options = new GitHubAuthenticationOptions
{
// TODO: move these to an external config file
ClientId = WebApp.Configuration.Current().GetClientId(),
ClientSecret = WebApp.Configuration.Current().GetClientSecret(),
Provider = new GitHubAuthenticationProvider
{
#pragma warning disable 1998
OnAuthenticated = async context =>
{
try
{
_apiDataCacheService.StoreApiData(context.UserName, ApiStorageConstants.APIDATA_KEY_APITOKEN, context.AccessToken);
// TODO: prefetch some data?
}
catch (Exception e)
{
throw;
}
}
#pragma warning restore 1998
},
};
options.Scope.Add("repo");
options.Scope.Add("user");
options.Scope.Add("user:email");
app.UseGitHubAuthentication(options);
}
private static void SetupGitHubAuth(IAppBuilder app)
{
GitHubAuthenticationOptions gitHubOptions = new GitHubAuthenticationOptions()
{
ClientId = GitHubClientId,
ClientSecret = GitHubClientSecret
};
app.UseGitHubAuthentication(gitHubOptions);
}
// For more information on configuring authentication, please visit http://go.microsoft.com/fwlink/?LinkId=301864
public static void ConfigureAuth(this IAppBuilder app)
{
var appSettings = ConfigurationManager.AppSettings;
// Configure the db context, user manager and signin manager to use a single instance per request
app.CreatePerOwinContext(CompetitionContext.Create);
app.CreatePerOwinContext<ApplicationUserManager>(ApplicationUserManager.Create);
app.CreatePerOwinContext<ApplicationSignInManager>(ApplicationSignInManager.Create);
// Enable the application to use a cookie to store information for the signed in user
// and to use a cookie to temporarily store information about a user logging in with a third party login provider
// Configure the sign in cookie
app.UseCookieAuthentication(new CookieAuthenticationOptions {
AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
LoginPath = new PathString("/Account/Login"),
Provider = new CookieAuthenticationProvider {
// Enables the application to validate the security stamp when the user logs in.
// This is a security feature which is used when you change a password or add an external login to your account.
OnValidateIdentity = SecurityStampValidator.OnValidateIdentity<ApplicationUserManager, ApplicationUser>(
validateInterval: TimeSpan.FromMinutes(30),
regenerateIdentity: (manager, user) => user.GenerateUserIdentityAsync(manager))
}
});
app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);
// Enables the application to temporarily store user information when they are verifying the second factor in the two-factor authentication process.
app.UseTwoFactorSignInCookie(DefaultAuthenticationTypes.TwoFactorCookie, TimeSpan.FromMinutes(5));
// Enables the application to remember the second login verification factor such as phone or email.
// Once you check this option, your second step of verification during the login process will be remembered on the device where you logged in from.
// This is similar to the RememberMe option when you log in.
app.UseTwoFactorRememberBrowserCookie(DefaultAuthenticationTypes.TwoFactorRememberBrowserCookie);
// Uncomment the following lines to enable logging in with third party login providers
// app.UseFacebookAuthentication(new FacebookAuthenticationOptions {
// AppId = appSettings["FacebookAppId"],
// AppSecret = appSettings["FacebookAppSecret"]
// });
// app.UseTwitterAuthentication(new TwitterAuthenticationOptions {
// ConsumerKey = appSettings["TwitterConsumerKey"],
// ConsumerSecret = appSettings["TwitterConsumerSecret"]
// });
app.UseGoogleAuthentication(new GoogleOAuth2AuthenticationOptions {
ClientId = appSettings["GoogleClientId"],
ClientSecret = appSettings["GoogleClientSecret"]
});
app.UseMicrosoftAccountAuthentication(new MicrosoftAccountAuthenticationOptions {
ClientId = appSettings["MicrosoftClientId"],
ClientSecret = appSettings["MicrosoftClientSecret"]
});
var githubOptions = new GitHubAuthenticationOptions {
ClientId = appSettings["GitHubClientId"],
ClientSecret = appSettings["GitHubClientSecret"],
};
githubOptions.Scope.Clear();
githubOptions.Scope.Add("user:email");
app.UseGitHubAuthentication(githubOptions);
app.UseLinkedInAuthentication(new LinkedInAuthenticationOptions {
ClientId = appSettings["LinkedInClientId"],
ClientSecret = appSettings["LinkedInClientSecret"]
});
}
