public async Task <IHttpActionResult> RegisterExternal(RegisterExternalBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var info = await Authentication.GetExternalLoginInfoAsync();
if (info == null)
{
return(InternalServerError());
}
var user = new ApplicationUser()
{
UserName = model.Email, Email = model.Email
};
IdentityResult result = await AppUserManager.CreateAsync(user);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
result = await AppUserManager.AddLoginAsync(user.Id, info.Login);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
public async Task <IActionResult> OnGetLinkLoginCallbackAsync()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
var info = await _signInManager.GetExternalLoginInfoAsync(await _userManager.GetUserIdAsync(user));
if (info == null)
{
throw new InvalidOperationException($"Unexpected error occurred loading external login info for user with ID '{user.Id}'.");
}
var result = await _userManager.AddLoginAsync(user, info);
if (!result.Succeeded)
{
throw new InvalidOperationException($"Unexpected error occurred adding external login for user with ID '{user.Id}'.");
}
// Clear the existing external cookie to ensure a clean login process
await HttpContext.SignOutAsync(IdentityConstants.ExternalScheme);
StatusMessage = "The external login was added.";
return(RedirectToPage());
}
public async Task <ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
var info = await AuthenticationManager.GetExternalLoginInfoAsync();
var user = new AppUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user);
if (result.Succeeded)
{
result = await UserManager.AddLoginAsync(user.Id, info.Login);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
MigrateShoppingCart(model.Email);
return(RedirectToLocal(returnUrl));
}
}
AddErrors(result);
}
ViewBag.ReturnUrl = returnUrl;
return(View(model));
}
public async Task <IHttpActionResult> AddExternalLogin(AddExternalLoginBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Authentication.SignOut(DefaultAuthenticationTypes.ExternalCookie);
AuthenticationTicket ticket = AccessTokenFormat.Unprotect(model.ExternalAccessToken);
if (ticket == null || ticket.Identity == null || (ticket.Properties != null &&
ticket.Properties.ExpiresUtc.HasValue &&
ticket.Properties.ExpiresUtc.Value < DateTimeOffset.UtcNow))
{
return(BadRequest("External login failure."));
}
ExternalLoginData externalData = ExternalLoginData.FromIdentity(ticket.Identity);
if (externalData == null)
{
return(BadRequest("The external login is already associated with an account."));
}
IdentityResult result = await AppUserManager.AddLoginAsync(User.Identity.GetUserId(),
new UserLoginInfo(externalData.LoginProvider, externalData.ProviderKey));
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
//
// GET: /Account/LinkLoginCallback
public async Task <ActionResult> LinkLoginCallback()
{
var loginInfo = await AuthenticationManager.GetExternalLoginInfoAsync(XsrfKey, User.Identity.GetUserId());
if (loginInfo == null)
{
return(RedirectToAction("Manage", new { Message = ManageMessageId.Error }));
}
var result = await UserManager.AddLoginAsync(User.Identity.GetUserId(), loginInfo.Login);
if (result.Succeeded)
{
return(RedirectToAction("Manage"));
}
return(RedirectToAction("Manage", new { Message = ManageMessageId.Error }));
}
public async Task <IActionResult> GoogleResponse()
{
ExternalLoginInfo info = await AppSignInManager.GetExternalLoginInfoAsync();
var result = await AppSignInManager.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, false);
string[] userInfo = { info.Principal.FindFirst(ClaimTypes.Name).Value, info.Principal.FindFirst(ClaimTypes.Email).Value };
if (result.Succeeded)
{
return(LocalRedirect("/"));
}
else
{
AppUser user = new AppUser
{
Email = info.Principal.FindFirst(ClaimTypes.Email).Value,
UserName = info.Principal.FindFirst(ClaimTypes.Email).Value,
};
IdentityResult identResult = await AppUserManager.CreateAsync(user);
if (identResult.Succeeded)
{
identResult = await AppUserManager.AddLoginAsync(user, info);
if (identResult.Succeeded)
{
await AppSignInManager.SignInAsync(user, false);
return(LocalRedirect("/"));
}
}
return(LocalRedirect("/"));
}
}
public async Task <IApiResponse> HandleAsync(IApiRequest request)
{
var phone = request.Body.Get <String>("phone");
var name = request.Body.Get <String>("name");
var email = request.Body.Get <String>("email");
var id = request.Body.Get <String>("id");
if (String.IsNullOrEmpty(id))
{
return(Fail("id required"));
}
if (String.IsNullOrEmpty(email))
{
return(Fail("email required"));
}
if (String.IsNullOrEmpty(phone))
{
return(Fail("phone required"));
}
if (String.IsNullOrEmpty(name))
{
return(Fail("name required"));
}
var user = await _userManager.FindByNameAsync(email);
if (user != null)
{
return(Fail("Email already taken"));
}
user = await _userManager.FindAsync(new UserLoginInfo("PhoneNumber", phone));
if (user != null)
{
return(Fail("Phone already taken"));
}
user = new AppUser()
{
UserName = email,
Email = email,
PhoneNumber = phone,
PersonName = name,
Tenant = -1,
};
var result = await _userManager.CreateAsync(user);
if (!result.Succeeded)
{
return(Fail(String.Join(",", result.Errors)));
}
await _userManager.AddLoginAsync(user.Id, new UserLoginInfo("ExternalId", id.ToUpperInvariant()));
user.SetEMailConfirmed();
await _userManager.UpdateUser(user);
return(Ok());
}
public async Task <IdentityResult> AddLoginAsync(string userId, UserLoginInfo loginInfo)
{
try
{
return(await AppUserManager.AddLoginAsync(userId, loginInfo));
}
catch (Exception)
{
return(null);
}
}
public async Task <IHttpActionResult> RegisterExternal(RegisterExternalBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var verifiedAccessToken = await VerifyExternalAccessToken(model.Provider, model.ExternalAccessToken);
if (verifiedAccessToken == null)
{
return(BadRequest("Invalid Provider or External Access Token"));
}
var user = await AppUserManager.FindAsync(new UserLoginInfo(model.Provider, verifiedAccessToken.user_id));
bool hasRegistered = user != null;
if (hasRegistered)
{
return(BadRequest("External user is already registered"));
}
user = new Backer()
{
UserName = model.UserName
};
IdentityResult result = await AppUserManager.CreateAsync(user);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
var info = new ExternalLoginInfo()
{
DefaultUserName = model.UserName,
Login = new UserLoginInfo(model.Provider, verifiedAccessToken.user_id)
};
result = await AppUserManager.AddLoginAsync(user.Id, info.Login);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
//generate access token response
var accessTokenResponse = GenerateLocalAccessTokenResponse(model.UserName);
return(Ok(accessTokenResponse));
}
public async Task <IHttpActionResult> RegisterExternal(ExternalUserAddRequest model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var externalAccessToken = await VerifyExternalAccessToken(model.Provider, model.ExternalAccessToken);
if (externalAccessToken == null)
{
return(BadRequest("Invalid Provider or External Access Token"));
}
AppUser appUser = await AppUserManager.FindAsync(new UserLoginInfo(model.Provider, externalAccessToken.user_id));
if (appUser != null)
{
return(BadRequest("External user is already registered"));
}
appUser = new AppUser {
UserName = model.Username, Email = model.Email, EmailConfirmed = true, JoinDate = DateTime.Now
};
IdentityResult result = await AppUserManager.CreateAsync(appUser, model.Password);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
IdentityResult addUserToRoleResult = await AppUserManager.AddToRoleAsync(appUser.Id, "user");
if (!addUserToRoleResult.Succeeded)
{
return(GetErrorResult(addUserToRoleResult));
}
var info = new ExternalLoginInfo
{
DefaultUserName = model.Username,
Login = new UserLoginInfo(model.Provider, externalAccessToken.user_id)
};
result = await AppUserManager.AddLoginAsync(appUser.Id, info.Login);
return(result.Succeeded ? Ok(GenerateLocalAccessTokenResponse(model.Username)) : GetErrorResult(result));
}
public async Task <IActionResult> ExternalLoginConfirm(ExternalLoginConfirm model, string returnTo = null)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(View("Error"));
}
var user = new User
{
Email = model.Email,
UserName = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
await _signInManager.UpdateExternalAuthenticationTokensAsync(info);
return(RedirectToLocal(returnTo));
}
AddErrors(result);
return(View());
}
AddErrors(result);
return(View());
}
public async Task <IActionResult> OnPostConfirmationAsync(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)
{
ErrorMessage = "Error loading external login information during confirmation.";
return(RedirectToPage("./Login", new { ReturnUrl = returnUrl }));
}
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = Input.Email, Email = Input.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(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
LoginProvider = info.LoginProvider;
ReturnUrl = returnUrl;
return(Page());
}
public async Task <ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl)
{
if (User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index", "Manage"));
}
if (ModelState.IsValid)
{
// Obtener datos del usuario del proveedor de inicio de sesión externo
var info = await AuthenticationManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(View("ExternalLoginFailure"));
}
var user = new AppUser {
Id = Guid.NewGuid().ToString(), UserName = model.Email, Email = model.Email, EmailConfirmed = true
};
var result = await UserManager.CreateAsync(user);
if (result.Succeeded)
{
result = await UserManager.AddLoginAsync(user.Id, info.Login);
if (result.Succeeded)
{
await SignInManager.ExternalSignInAsync(info, isPersistent : false);
return(RedirectToLocal(returnUrl));
}
}
AddErrors(result);
}
ViewBag.ReturnUrl = returnUrl;
return(View(model));
}
public async Task <ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl)
{
if (User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index", "Manage"));
}
if (ModelState.IsValid)
{
// 从外部登录提供程序获取有关用户的信息
var info = await AuthenticationManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(View("ExternalLoginFailure"));
}
var user = new AppUser {
UserName = model.Email, Email = model.Email
};
var result = await UserManager.CreateAsync(user);
if (result.Succeeded)
{
result = await UserManager.AddLoginAsync(user.Id, info.Login);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToLocal(returnUrl));
}
}
AddErrors(result);
}
ViewBag.ReturnUrl = returnUrl;
return(View(model));
}
