public ActionResult ExternalLoginConfirmation(RegisterExternalLoginViewModel model, string returnUrl)
{
string provider = null;
string providerUserId = null;
if (User.Identity.IsAuthenticated || !OAuthWebSecurity.TryDeserializeProviderUserId(model.ExternalLoginData, out provider, out providerUserId))
{
return(RedirectToAction("Manage"));
}
if (ModelState.IsValid)
{
// Insert a new user into the database
using (Context db = new Context())
{
User user = db.Users.FirstOrDefault(u => u.UserName.ToLower() == model.UserName.ToLower());
// Check if user already exists
if (user == null)
{
// Insert name into the profile table
db.Users.Add(new User {
UserName = model.UserName
});
db.SaveChanges();
OAuthWebSecurity.CreateOrUpdateAccount(provider, providerUserId, model.UserName);
OAuthWebSecurity.Login(provider, providerUserId, createPersistentCookie: false);
return(RedirectToLocal(returnUrl));
}
else
{
ModelState.AddModelError("UserName", "User name already exists. Please enter a different user name.");
}
}
}
ViewBag.ProviderDisplayName = OAuthWebSecurity.GetOAuthClientData(provider).DisplayName;
ViewBag.ReturnUrl = returnUrl;
return(View(model));
}
public async Task <IActionResult> RegisterExternalLogin(RegisterExternalLoginViewModel model, string returnUrl = null)
{
IUser user = null;
var settings = (await _siteService.GetSiteSettingsAsync()).As <RegistrationSettings>();
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
_logger.LogWarning("Error loading external login info.");
return(NotFound());
}
if (settings.UsersCanRegister == UserRegistrationType.NoRegistration)
{
_logger.LogWarning("Site does not allow user registration.", model.UserName, model.Email);
return(NotFound());
}
ViewData["ReturnUrl"] = returnUrl;
ViewData["LoginProvider"] = info.LoginProvider;
model.NoPassword = settings.NoPasswordForExternalUsers;
model.NoEmail = settings.NoEmailForExternalUsers;
model.NoUsername = settings.NoUsernameForExternalUsers;
ModelState.Clear();
if (model.NoEmail)
{
var email = info.Principal.FindFirstValue(ClaimTypes.Email) ?? info.Principal.FindFirstValue("email");
model.Email = email;
}
if (model.NoUsername)
{
model.UserName = await GenerateUsername(info);
}
if (model.NoPassword)
{
model.Password = null;
model.ConfirmPassword = null;
}
if (TryValidateModel(model) && ModelState.IsValid)
{
user = await this.RegisterUser(new RegisterViewModel()
{
UserName = model.UserName, Email = model.Email, Password = model.Password, ConfirmPassword = model.ConfirmPassword
}, S["Confirm your account"], _logger);
if (user is null)
{
ModelState.AddModelError(string.Empty, "Registration Failed.");
}
else
{
var identityResult = await _signInManager.UserManager.AddLoginAsync(user, new UserLoginInfo(info.LoginProvider, info.ProviderKey, info.ProviderDisplayName));
if (identityResult.Succeeded)
{
_logger.LogInformation(3, "User account linked to {provider} provider.", info.LoginProvider);
// we have created/linked to the local user, so we must verify the login. If it does not succeed,
// the user is not allowed to login
var signInResult = await ExternalLoginSignInAsync(user, info);
if (signInResult.Succeeded)
{
return(await LoggedInActionResult(user, returnUrl, info));
}
}
AddIdentityErrors(identityResult);
}
}
return(View("RegisterExternalLogin", model));
}
public async Task <IActionResult> ExternalLoginCallback(string returnUrl = null, string remoteError = null)
{
if (remoteError != null)
{
_logger.LogError("Error from external provider: {Error}", remoteError);
return(RedirectToAction(nameof(Login)));
}
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
_logger.LogError("Could not get external login info.");
return(RedirectToAction(nameof(Login)));
}
var registrationSettings = (await _siteService.GetSiteSettingsAsync()).As <RegistrationSettings>();
var user = await _userManager.FindByLoginAsync(info.LoginProvider, info.ProviderKey);
if (user != null)
{
if (!await AddConfirmEmailError(user))
{
await _accountEvents.InvokeAsync((e, user, modelState) => e.LoggingInAsync(user.UserName, (key, message) => modelState.AddModelError(key, message)), user, ModelState, _logger);
var signInResult = await ExternalLoginSignInAsync(user, info);
if (signInResult.Succeeded)
{
return(await LoggedInActionResult(user, returnUrl, info));
}
else
{
ModelState.AddModelError(string.Empty, S["Invalid login attempt."]);
}
}
}
else
{
var email = info.Principal.FindFirstValue(ClaimTypes.Email) ?? info.Principal.FindFirstValue("email");
if (!string.IsNullOrWhiteSpace(email))
{
user = await _userManager.FindByEmailAsync(email);
}
ViewData["ReturnUrl"] = returnUrl;
ViewData["LoginProvider"] = info.LoginProvider;
if (user != null)
{
// Link external login to an existing user
ViewData["UserName"] = user.UserName;
ViewData["Email"] = email;
return(View("LinkExternalLogin"));
}
else
{
// no user could be matched, check if a new user can register
if (registrationSettings.UsersCanRegister == UserRegistrationType.NoRegistration)
{
string message = S["Site does not allow user registration."];
_logger.LogWarning(message);
ModelState.AddModelError("", message);
}
else
{
var externalLoginViewModel = new RegisterExternalLoginViewModel();
externalLoginViewModel.NoPassword = registrationSettings.NoPasswordForExternalUsers;
externalLoginViewModel.NoEmail = registrationSettings.NoEmailForExternalUsers;
externalLoginViewModel.NoUsername = registrationSettings.NoUsernameForExternalUsers;
// If registrationSettings.NoUsernameForExternalUsers is true, this username will not be used
externalLoginViewModel.UserName = await GenerateUsername(info);
externalLoginViewModel.Email = email;
// The user doesn't exist, if no information required, we can create the account locally
// instead of redirecting to the ExternalLogin
var noInformationRequired = externalLoginViewModel.NoPassword &&
externalLoginViewModel.NoEmail &&
externalLoginViewModel.NoUsername;
if (noInformationRequired)
{
user = await this.RegisterUser(new RegisterViewModel()
{
UserName = externalLoginViewModel.UserName,
Email = externalLoginViewModel.Email,
Password = null,
ConfirmPassword = null
}, S["Confirm your account"], _logger);
// If the registration was successful we can link the external provider and redirect the user
if (user != null)
{
var identityResult = await _signInManager.UserManager.AddLoginAsync(user, new UserLoginInfo(info.LoginProvider, info.ProviderKey, info.ProviderDisplayName));
if (identityResult.Succeeded)
{
_logger.LogInformation(3, "User account linked to {LoginProvider} provider.", info.LoginProvider);
// We have created/linked to the local user, so we must verify the login.
// If it does not succeed, the user is not allowed to login
var signInResult = await ExternalLoginSignInAsync(user, info);
if (signInResult.Succeeded)
{
return(await LoggedInActionResult(user, returnUrl, info));
}
else
{
ModelState.AddModelError(string.Empty, S["Invalid login attempt."]);
return(View(nameof(Login)));
}
}
AddIdentityErrors(identityResult);
}
}
return(View("RegisterExternalLogin", externalLoginViewModel));
}
}
}
return(RedirectToAction(nameof(Login)));
}
