public IEnumerable <ExternalLoginModel> GetExternalLogins(string returnUrl, bool generateState = false)
{
var providers = Authentication.GetExternalAuthenticationTypes();
var logins = new List <ExternalLoginModel>();
string state = null;
foreach (var description in providers)
{
var login = new ExternalLoginModel
{
Name = description.Caption,
Url = Url.Link("ExternalLogin", new
{
provider = description.AuthenticationType,
response_type = "token",
client_id = PublicClientId,
redirect_uri = new Uri(Request.RequestUri, returnUrl).AbsoluteUri,
state
}),
State = state
};
logins.Add(login);
}
return(logins);
}
public async Task <IActionResult> ExternalLoginFormAction(ExternalLoginModel model)
{
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
ExternalLoginInfo info = await _authentication.GetExternalLoginInfoAsync();
if (info == null)
{
throw new ApplicationException("Error loading external login information during confirmation.");
}
//var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
//var result = await _userManager.CreateAsync(user);
RegistrationResult result = await _registration.RegisterAsync(model.Login, model.Email);
if (result == RegistrationResult.Success)
{
IdentityResult identResult = await _moneyUserManager.AddLoginAsync(model.Login, info);
if (identResult.Succeeded)
{
//await _signInManager.SignInAsync(user, isPersistent: false);
await _authentication.SignInAsync(model.Login, false);
await _logManager.WriteAsync(model.Login, $"New user '{model.Login}' was registered with {info.ProviderDisplayName}.");
//_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
//return RedirectToLocal(returnUrl);
return(RedirectToAction(nameof(HomeController.Index), "Home"));
}
}
//AddErrors(result);
}
return(View(nameof(ExternalLogin), model));
}
public async Task <IActionResult> ExternalLoginConfirmation(ExternalLoginModel model, string returnUrl = null)
{
if (ModelState.IsValid)
{
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(BadRequest("Error loading external login information during confirmation."));
}
var user = new IdentityUser {
UserName = model.Username, Email = model.Email
};
var result = await _userManager.CreateAsync(user);
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
await SendEmailConfirmation(user, returnUrl);
return(View(nameof(ConfirmEmail)));
}
AddErrors(result);
}
ViewData["ReturnUrl"] = returnUrl;
return(View(nameof(ExternalLogin), model));
}
public async Task <IActionResult> ExternalLoginConfirmation(ExternalLoginModel elm)
{
if (ModelState.IsValid)
{
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(RedirectToAction(nameof(Login)));
}
var user = new ApplicationUser {
UserName = elm.Email, Email = elm.Email
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(RedirectToAction("Index", "Home"));
}
}
}
return(View(nameof(ExternalLogin), elm));
}
public static void SingIn(IOwinContext owinContext, ExternalLoginModel externalLogin)
{
var claimsMapper = new NotRegisteredExternal(externalLogin);
var identity = CreateIdentity(claimsMapper, OAuthDefaults.AuthenticationType);
owinContext.Authentication.SignIn(identity);
}
public async Task <ActionResult> ExternalLoginCallback(string returnUrl)
{
var ctx = Request.GetOwinContext();
var result = await ctx.Authentication.AuthenticateAsync("ExternalCookie");
ctx.Authentication.SignOut("ExternalCookie");
var externalLogin = ExternalLoginModel.FromIdentity(result.Identity);
if (externalLogin == null)
{
return(new HttpStatusCodeResult(500));
}
var claims = result.Identity.Claims.ToList();
claims.Add(new Claim(ClaimTypes.AuthenticationMethod, "Google"));
var ci = new ClaimsIdentity(claims, "Cookie");
ctx.Authentication.SignIn(ci);
Session["ExternalLoginModel"] = externalLogin;
if (!String.IsNullOrEmpty(returnUrl))
{
return(new RedirectResult(returnUrl));
}
return(RedirectToAction("Index", "Dashboard", new { area = "Account" }));
}
public async Task <IActionResult> ExternalLoginConfirmation(ExternalLoginModel model, string returnUrl = null)
{
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
throw new ApplicationException("Error loading external login information during confirmation.");
}
var user = new User {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
return(RedirectToLocal(returnUrl));
}
}
AddErrors(result);
}
ViewData["ReturnUrl"] = returnUrl;
return(View(nameof(ExternalLogin), model));
}
public async Task <IActionResult> ConfirmationAsync(ExternalLoginModel model, string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
model.ErrorMessage = "Error loading external login information during confirmation.";
return(RedirectToAction("Login", new { ReturnUrl = returnUrl }));
}
if (ModelState.IsValid)
{
var user = new User {
UserName = model.Input.Email, Email = model.Input.Email
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Action("ConfirmEmail", values: new { userId = userId, code = code });
await _emailSender.SendEmailAsync(model.Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
// If account confirmation is required, we need to show the link if we don't have a real email sender
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToAction("RegisterConfirmation", new { Email = model.Input.Email }));
}
await _signInManager.SignInAsync(user, isPersistent : false, info.LoginProvider);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
model.ProviderDisplayName = info.ProviderDisplayName;
model.ReturnUrl = returnUrl;
return(View(model));
}
public async Task <IActionResult> ExternalLoginConfirmation(ExternalLoginModel model, string returnUrl = null)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(StatusCode(500));
}
var user = await _userManager.FindByEmailAsync(model.Email);
IdentityResult result;
if (user != null)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(RedirectToAction("Index", "Home"));
}
}
else
{
var newUser = new User
{
UserName = model.Email,
Email = model.Email
};
result = await _userManager.CreateAsync(newUser);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(newUser, info);
if (result.Succeeded)
{
//TODO: Send an emal for the email confirmation and add a default role as in the Register action
await _signInManager.SignInAsync(newUser, isPersistent : false);
return(RedirectToAction("Index", "Home"));
}
}
}
foreach (var error in result.Errors)
{
ModelState.TryAddModelError(error.Code, error.Description);
}
return(View(nameof(ExternalLoginConfirmation), model));
}
public async Task <IActionResult> ExternalLoginConfirmation(ExternalLoginModel model, string returnUrl = null)
{
if (await Configurations.GetBooleanAsync("enable_register") == false)
{
return(ExternalRegisterClosed());
}
var check = new RegisterNotification(model.Username);
await Mediator.Publish(check);
if (check.Failed)
{
ModelState.AddModelError("xys::custom_rule", "The username is invalid. Please change another one.");
}
if (!ModelState.IsValid)
{
ViewData["ReturnUrl"] = returnUrl;
return(View(nameof(ExternalLogin), model));
}
// Get the information about the user from the external login provider
var info = await SignInManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(Message(
title: "External login",
message: "Error loading external login information during confirmation.",
type: BootstrapColor.danger));
}
var user = UserManager.CreateEmpty(model.Username);
user.Email = model.Email;
user.RegisterTime = DateTimeOffset.Now;
var result = await UserManager.CreateAsync(user);
if (result.Succeeded)
{
result = await UserManager.AddLoginAsync(user, info);
}
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false);
await HttpContext.AuditAsync(
"registered",
user.Id.ToString(),
$"at {HttpContext.Connection.RemoteIpAddress} via {info.LoginProvider}");
return(RedirectToLocal(returnUrl));
}
else
{
return(ErrorView(result, model, nameof(ExternalLogin)));
}
}
//[ValidateAntiForgeryToken]
public IActionResult ExternalLogin([FromBody] ExternalLoginModel model)
{
// Request a redirect to the external login provider.
var redirectUrl = Url.Action(nameof(RegisterFBUser), "Account", new { model.ReturnUrl });
var properties = _signInManager.ConfigureExternalAuthenticationProperties(model.Provider, redirectUrl);
return(Challenge(properties, model.Provider));
}
public async Task <IActionResult> ExternalLoginConfirmation(ExternalLoginModel model, string returnUrl = null)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(View(nameof(Error)));
}
var user = await _userManager.FindByEmailAsync(model.Email);
IdentityResult result;
if (user != null)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(RedirectToLocal(returnUrl));
}
}
else
{
model.Principal = info.Principal;
user = _mapper.Map <User>(model);
result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
//TODO: Send an emal for the email confirmation and add a default role as in the Register action
await _signInManager.SignInAsync(user, isPersistent : false);
return(RedirectToLocal(returnUrl));
}
}
}
foreach (var error in result.Errors)
{
ModelState.TryAddModelError(error.Code, error.Description);
}
return(View(nameof(ExternalLogin), model));
}
public void ExternalLoginModelIsString()
{
ExternalLoginModel external = new ExternalLoginModel
{
Email = "*****@*****.**"
};
var test = external.Email;
Assert.IsType <string>(test);
}
public static void SingIn(IOwinContext owinContext, User user, ExternalLoginModel externalLogin)
{
owinContext.Authentication.SignOut(DefaultAuthenticationTypes.ExternalCookie);
var claimsMapper = new RegisteredExternal(user, externalLogin);
var oAuthIdentity = CreateIdentity(claimsMapper, OAuthDefaults.AuthenticationType);
var cookieIdentity = CreateIdentity(claimsMapper, CookieAuthenticationDefaults.AuthenticationType);
var properties = CreateProperties(user);
owinContext.Authentication.SignIn(properties, oAuthIdentity, cookieIdentity);
}
public void ExternalLoginModel()
{
ExternalLoginModel external = new ExternalLoginModel
{
Email = "*****@*****.**"
};
var test = external.Email;
Assert.Equal(test, "*****@*****.**");
}
private static Task <byte[]> GetExternalAvatarAsync(ExternalLoginModel externalInfo)
{
if (string.IsNullOrEmpty(externalInfo.AvatarUrl))
{
return(null);
}
var client = HttpHelper.CreateHttpClient();
return(client.GetByteArrayAsync(externalInfo.AvatarUrl));
}
public static UserViewModel MapUserToViewModel(User user, ExternalLoginModel externalLogin)
{
return(new UserViewModel
{
Email = user.Email,
FullName = user.FullName,
IsVerified = user.IsVerified,
AvatarUrl = GetAvatarUrl(user),
IsRegistered = true,
LoginProvider = externalLogin.Provider.ToString()
});
}
public RegisteredExternal(User user, ExternalLoginModel extLogin)
{
this.Id = user.Id.ToString();
this.Email = user.Email;
this.FullName = user.FullName ?? string.Empty;
this.AvatarUrl = UserProvider.GetAvatarUrl(user);
this.Sid = extLogin.ProviderKey;
this.Version = this.GetVersion(user.TimeStamp);
this.IsVerified = user.IsVerified.ToString();
this.Issuer = ClaimsIdentity.DefaultIssuer;
this.OriginalIssuer = extLogin.Provider.ToString();
}
public void Validate_ValidModel()
{
var model = new ExternalLoginModel
{
Email = "*****@*****.**"
};
var result = target.Validate(model);
Assert.IsTrue(result.IsValid);
target.ShouldNotHaveValidationErrorFor(x => x.Email, model);
}
public NotRegisteredExternal(ExternalLoginModel extLogin)
{
this.Id = string.Empty;
this.Email = extLogin.Email ?? string.Empty;
this.FullName = extLogin.FullName ?? string.Empty;
this.AvatarUrl = extLogin.AvatarUrl ?? string.Empty;
this.Sid = extLogin.ProviderKey;
this.Version = string.Empty;
this.IsVerified = false.ToString();
this.Issuer = extLogin.Provider.ToString();
this.OriginalIssuer = this.Issuer;
}
public async Task <IActionResult> ExternalLogin(string remoteError = null)
{
if (remoteError != null)
{
return(RedirectToAction("Error", "Home"));
}
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(RedirectToAction("Error", "Home"));
}
var returnUrl = info.AuthenticationProperties.Items["returnUrl"] ?? Url.Content("~/AccountManage");
var result = await _signInManager.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, isPersistent : false, bypassTwoFactor : true);
if (result.Succeeded)
{
return(Redirect(returnUrl));
}
if (result.IsLockedOut)
{
return(RedirectToAction("Error", "Home"));
}
else
{
var externalLoginModel = new ExternalLoginModel();
externalLoginModel.LoginProvider = info.LoginProvider;
externalLoginModel.Claims = info.Principal.Claims;
if (info.Principal.HasClaim(c => c.Type == ClaimTypes.Email))
{
var email = info.Principal.FindFirstValue(ClaimTypes.Email);
externalLoginModel.Email = email;
var exsistApplicationUser = await _userManager.FindByNameAsync(email);
if (exsistApplicationUser != null)
{
var addProviderResult = await _userManager.AddLoginAsync(exsistApplicationUser, info);
if (addProviderResult.Succeeded)
{
await _signInManager.SignInAsync(exsistApplicationUser, isPersistent : false);
return(Redirect(returnUrl));
}
}
}
return(View(externalLoginModel));
}
}
public IHttpActionResult PutExternalLogin(int id, ExternalLoginModel externalLogin)
{
// Allow only for authorized user
var userToCheck = _userRepository.FirstOrDefault(u => u.UserName == User.Identity.Name);
if (!userToCheck.Authorized)
{
return(Unauthorized());
}
// Validate the request
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != externalLogin.ExternalLoginID)
{
return(BadRequest());
}
// Get the DB externalLogin, update it according to the input ExternalLoginModel object,
// and then update the DB externalLogin in the database
var dbExternalLogin = _externalLoginRepository.GetByID(id);
if (dbExternalLogin == null)
{
return(NotFound());
}
dbExternalLogin.Update(externalLogin);
_externalLoginRepository.Update(dbExternalLogin);
// Save database changes
try
{
_unitOfWork.Commit();
}
catch (DBConcurrencyException e)
{
if (!ExternalLoginExists(id))
{
return(NotFound());
}
else
{
throw new Exception("Unable to update the externalLogin in the database", e);
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IHttpActionResult> ExternalLoginCallback(string provider)
{
_logger.Debug(string.Format("ini ExternalLoginCallback process - provider:{0}", provider));
string redirectUri = string.Empty;
if (!User.Identity.IsAuthenticated)
{
_logger.Debug("ExternalLoginCallback IsAuthenticated");
return(new ChallengeResult(provider, this));
}
var redirectUriValidationResult = Helpers.ValidateClientAndRedirectUri(ref redirectUri, Request);
if (!string.IsNullOrWhiteSpace(redirectUriValidationResult))
{
_logger.Debug("ExternalLoginCallback BadRequest");
return(BadRequest(redirectUriValidationResult));
}
ExternalLoginModel externalLogin = ExternalLoginModel.FromIdentity(User.Identity as ClaimsIdentity);
if (externalLogin == null)
{
_logger.Debug("ExternalLoginCallback InternalServerError");
return(InternalServerError());
}
if (externalLogin.LoginProvider != provider)
{
_logger.Debug("ExternalLoginCallback SignOut different providers");
Authentication.SignOut(DefaultAuthenticationTypes.ExternalCookie);
return(new ChallengeResult(provider, this));
}
User user = await _appUserManager.FindAsync(new UserLoginInfo(externalLogin.LoginProvider, externalLogin.ProviderKey));
bool hasRegistered = user != null;
if (hasRegistered && user.Disabled)
{
return(BadRequest("Your account is disabled, please contact with the web master"));
}
redirectUri = string.Format("{0}?externalAccessToken={1}&provider={2}&haslocalaccount={3}&userName={4}&email={5}",
redirectUri, externalLogin.ExternalAccessToken, externalLogin.LoginProvider,
hasRegistered, externalLogin.UserName, externalLogin.Email);
_logger.Debug(string.Format("ExternalLoginCallback Redirect info provider:{0},hasRegistered:{1},externalLogin.UserName:{2},externalLogin.Email{3}", provider, hasRegistered, externalLogin.UserName, externalLogin.Email));
return(Redirect(redirectUri));
}
public async Task <IHttpActionResult> GetExternalLogin(string provider, string error = null)
{
if (error != null)
{
return(Redirect(Url.Content("~/") + "#error=" + Uri.EscapeDataString(error)));
}
ExternalLoginProvider loginProvider;
if (!Enum.TryParse <ExternalLoginProvider>(provider, ignoreCase: true, result: out loginProvider) ||
loginProvider == ExternalLoginProvider.None)
{
//Unsupported login provider
return(InternalServerError());
}
if (!User.Identity.IsAuthenticated)
{
return(new ChallengeResult(loginProvider, this));
}
ExternalLoginModel externalLogin = ExternalLoginModel.FromIdentity(User.Identity as ClaimsIdentity);
if (externalLogin == null)
{
return(InternalServerError());
}
if (externalLogin.Provider != loginProvider)
{
Request.GetOwinContext().Authentication.SignOut(
DefaultAuthenticationTypes.ExternalCookie,
OAuthDefaults.AuthenticationType,
CookieAuthenticationDefaults.AuthenticationType);
return(new ChallengeResult(loginProvider, this));
}
User user = await this.UserProvider.FindAsync(externalLogin.Provider, externalLogin.ProviderKey);
if (user != null)
{
OwinHelper.SingIn(Request.GetOwinContext(), user, externalLogin);
}
else
{
OwinHelper.SingIn(Request.GetOwinContext(), externalLogin);
}
return(Ok());
}
public IActionResult ExternalLogin([FromQuery] ExternalLoginModel model)
{
var authenticationProperties = new AuthenticationProperties()
{
RedirectUri = Url.Action(nameof(ExternalLoginCallback)),
Items =
{
{ "returnUrl", model.ReturnUrl },
{ "scheme", model.Provider },
}
};
return(Challenge(authenticationProperties, model.Provider));
}
public async Task <string> GmailLogin(ExternalLoginModel model)
{
var accessTokenValidationResponse = await this.client.GetAsync(string.Format(GmailLoginVerifier, model.Token));
try
{
accessTokenValidationResponse.EnsureSuccessStatusCode();
}
catch (Exception e)
{
throw new Exception("Invalid Google+ Token.");
}
var content = JsonConvert.DeserializeObject <GoogleApiTokenInfo>(await accessTokenValidationResponse.Content.ReadAsStringAsync());
var user = await this.UserManager.FindByEmailAsync(content.email);
if (user is null)
{
var appUser = new User
{
Email = content.email,
UserName = content.email,
DateRegistered = DateTime.UtcNow
};
await this.UserManager.CreateAsync(appUser);
await this.UserManager.AddToRoleAsync(appUser, Enum.GetName(typeof(Roles), 2));
}
else
{
if (user.UserName != content.email)
{
throw new Exception("Email is already taken.");
}
}
user = await this.UserManager.FindByEmailAsync(content.email);
if (user.IsActive == false)
{
throw new UnauthorizedAccessException(UserBannedErrorMessage);
}
await this.LoginInfo(user.Id);
return(this.GenerateToken(user));
}
/// <summary>
/// 第三方登录授权获取token
/// </summary>
/// <param name="loginModel"></param>
/// <returns></returns>
public async Task <AjaxResponse> ExternalAuthenticate(ExternalLoginModel loginModel)
{
if (!ModelState.IsValid)
{
throw new UserFriendlyException("Invalid request!");
}
//后续需要校验第三方服务
var loginResult = await _logInManager.LoginAsync(new UserLoginInfo(loginModel.LoginProvider, loginModel.ProviderKey));
string token = GetToken(loginResult);
return(new AjaxResponse(token));
}
public async Task <User> CreateExternalAsync(ExternalLoginModel externalInfo)
{
var userRegistration = new UserRegistration()
{
Email = externalInfo.Email,
FullName = externalInfo.FullName,
Avatar = await GetExternalAvatarAsync(externalInfo),
ExternalLoginInfo = new ExternalLoginInfo
{
ProviderType = externalInfo.Provider,
ProviderKey = externalInfo.ProviderKey
}
};
return(await this.UsersManager.CreateUserAsync(userRegistration));
}
public async Task <IActionResult> FacebookLogin(ExternalLoginModel externalLoginModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _authService.FacebookLogin(externalLoginModel.AccessToken, externalLoginModel.Id);
if (result.Error != null)
{
return(Unauthorized(result));
}
return(Ok(result));
}
public async Task <IActionResult> ExternalLoginConfrmation(ExternalLoginModel model, string returnUrl = null)
{
if (!ModelState.IsValid)
{
return(View(model));
}
ExternalLoginInfo info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(View(nameof(Error)));
}
var user = await _userManager.FindByEmailAsync(model.Email);
IdentityResult result;
if (user != null)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : true);
return(SignInAndRedirectToAction(returnUrl));
}
}
else
{
result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : true);
return(SignInAndRedirectToAction(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.TryAddModelError(error.Code, error.Description);
}
return(View(nameof(ExternalAuth), model));
}