public async Task <IActionResult> RegisterExternalConfirmed(RegisterExternalModel model)
{
// Так как метод открытый, нужно проверить, что всетаки пользователь прошел external регистрацию
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
RedirectToAction(nameof(Login));
}
var user = new User(model.UserName);
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
var claimsResult = await _userManager.AddClaimAsync(user, new Claim(ClaimTypes.Role, Policies.AdministratorPolicy));
if (claimsResult.Succeeded)
{
var loginResult = await _userManager.AddLoginAsync(user, info);
if (loginResult.Succeeded)
{
await _signInManager.SignInAsync(user, false);
return(RedirectToAction(nameof(Index)));
}
}
}
return(View(model));
}
public async Task <IdentityResult> RegisterExternal(RegisterExternalModel model)
{
var info = await AuthenticationManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(new IdentityResult("External login info not found."));
}
var user = new AppUser {
UserName = model.UserName, Email = model.Email ?? ""
};
var result = await UserManager.CreateAsync(user);
if (!result.Succeeded)
{
return(result);
}
result = await UserManager.AddLoginAsync(user.Id, info.Login);
if (!result.Succeeded)
{
return(result);
}
return(await UserManager.AddToRoleAsync(user.Id, DefaultUserRole));
}
public async Task <IHttpActionResult> RegisterExternal(RegisterExternalModel model)
{
var verifiedAccessToken = new ParsedExternalAccessToken();
if (ModelState.IsValid)
{
var helper = OauthHelper.Create();
if (!string.IsNullOrEmpty(model.Provider) && !string.IsNullOrEmpty(model.ExternalAccessToken))
{
verifiedAccessToken = await helper.VerifyExternalAccessToken(model.Provider, model.ExternalAccessToken);
if (verifiedAccessToken == null)
{
return(this.JsonError(HttpStatusCode.BadRequest, 10, "Invalid Provider or External Access Token", ModelState));
}
}
var loginInfo = await SignInManager.AuthenticationManager.GetExternalLoginInfoAsync();
ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(loginInfo.ExternalIdentity as ClaimsIdentity);
var registerGeneral = new RegisterGeneralModel()
{
UserName = model.UserName,
Email = model.Email,
//FirstName = externalLogin.UserName.Split(' ')[0], //First Name
//LastName = externalLogin.UserName.Split(' ').LastOrDefault(), //Last Name
ExternalAccessToken = model.ExternalAccessToken,
Provider = model.Provider
};
var regResult = await RegisterInternal(registerGeneral);
if (regResult.HasError)
{
return(JsonError(regResult.HttpStatusCode, regResult.ServerErrorCode, regResult.ErrorMessage, regResult.ModelState));
}
else
{
var result = new
{
userId = regResult.UserId
};
return(Json(result));
}
}
else
{
return(JsonError(HttpStatusCode.BadRequest, 10, "Warning", ModelState));
}
}
public ActionResult ExternalLoginRegistration(RegisterExternalModel model, string returnUrl)
{
if (_workContext.CurrentProfile.IsAnonymous == false)
{
_authenticationService.SignOut();
}
var loginInfo = HttpContext.GetOwinContext().Authentication.GetExternalLoginInfo();
if (loginInfo == null)
{
return(RedirectToAction("ExternalLoginFailure"));
}
if (ModelState.IsValid)
{
var account = new Account
{
Name = model.Name,
Email = model.Email.ToLower(),
ContactNumber = model.ContactNumber,
DOB = model.ParseDateOfBirth().HasValue ? model.ParseDateOfBirth().Value.ToString("dd/MM/yyyy") : null,
Username = model.Email,
DisplayContactNumberInDespatch = model.DisplayContactNumberInDespatch,
ProfileId = _workContext.CurrentProfile.Id,
};
var result = _accountService.ProcessRegistrationWithExternalLogin(account, loginInfo.Login.LoginProvider, loginInfo.Login.ProviderKey, sendEmailFlag: true);
if (string.IsNullOrEmpty(result.Message))
{
account.Id = result.UserId;
_identityExternalAuthService.ExternalSignIn(loginInfo.Email, loginInfo.Login.LoginProvider, loginInfo.Login.ProviderKey, isPersistent: true);
return(RedirectToRoute("Register Result", new { resultId = Convert.ToInt32(UserRegistrationType.Standard), returnUrl }));
}
else
{
model.LoginProvider = loginInfo.Login.LoginProvider;
model.Email = loginInfo.Email;
ModelState.AddModelError(string.Empty, result.Message);
}
}
return(View(model));
}
public async Task <IActionResult> RegisterExternal(string id, RegisterExternalModel model)
{
var authResult = await HttpContext.AuthenticateAsync("TempCookie");
if (!authResult.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await userService.AddExternal(authResult.Principal.FindFirstValue(ClaimTypes.NameIdentifier), model.Name, model.Email);
return(await SignInExternal(user));
}
public IActionResult RegisterExternal(RegisterExternalModel model)
{
return(View(model));
}
public async Task<IHttpActionResult> RegisterExternal(RegisterExternalModel model)
{
return await RunTask(() => AccountManager.RegisterExternal(model));
}
public async Task <IHttpActionResult> RegisterExternal(RegisterExternalModel model)
{
return(await RunTask(() => AccountManager.RegisterExternal(model)));
}
