public async Task <ActionResult> Register(RegisterViewModel model, [FromForm(Name = "g-recaptcha-response")] string recaptchaToken)
{
var isRecaptchaConfigured = recaptchaVerificator.IsRecaptchaConfigured();
if (!ModelState.IsValid)
{
model.IsRecaptchaConfigured = isRecaptchaConfigured;
model.RecaptchaPublicKey = recaptchaOptions.Value.PublicKey;
return(View(model));
}
//this can be null i.e. under proxy or from localhost.
//TODO IISIntegration, etc
var clientIp = HttpContext.Connection.RemoteIpAddress;
if (isRecaptchaConfigured)
{
var isRecaptchaValid = await recaptchaVerificator.ValidateToken(recaptchaToken, clientIp);
if (!isRecaptchaValid)
{
ModelState.AddModelError("captcha", "Невозможно верифицировать ReCAPTCHA. Если эта ошибка повторяется, пожалуйста, обратитесь в техподдержку.");
model.IsRecaptchaConfigured = isRecaptchaConfigured;
model.RecaptchaPublicKey = recaptchaOptions.Value.PublicKey;
return(View(model));
}
}
var currentUser = await UserManager.FindByNameAsync(model.Email);
if (currentUser != null)
{
ModelState.AddModelError("",
"Вы уже зарегистрировались. Если пароль не подходит, нажмите «Забыли пароль?»");
var loginModel = await CreateLoginPageViewModelAsync("");
loginModel.Login.Email = model.Email;
return(View("Login", loginModel));
}
var user = new JoinIdentityUser {
UserName = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
ModelState.AddErrors(result);
model.IsRecaptchaConfigured = isRecaptchaConfigured;
model.RecaptchaPublicKey = recaptchaOptions.Value.PublicKey;
return(View(model));
}
//We don't want to sign in user until he has email confirmed
//await SignInManager.SignInAsync(user, isPersistent:false, rememberBrowser:false);
await SendConfirmationEmail(user);
return(View("RegisterSuccess"));
}
public async Task <ActionResult> ExternalLoginConfirmation(
ExternalLoginConfirmationViewModel model)
{
if (User.Identity?.IsAuthenticated == true)
{
return(RedirectToAction("Index", "Manage"));
}
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var loginInfo = await SignInManager.GetExternalLoginInfoAsync();
if (loginInfo == null)
{
return(View("ExternalLoginFailure"));
}
var email = loginInfo.Principal.FindFirstValue(ClaimTypes.Email);
var user = new JoinIdentityUser()
{
UserName = email
};
var result = await UserManager.CreateAsync(user);
if (result.Succeeded)
{
result = await UserManager.AddLoginAsync(user, loginInfo);
if (result.Succeeded)
{
var token = await UserManager.GenerateEmailConfirmationTokenAsync(user);
_ = await UserManager.ConfirmEmailAsync(user, token);
await SignInManager.SignInAsync(user, isPersistent : true);
await externalLoginProfileExtractor.TryExtractProfile(user, loginInfo);
return(RedirectToLocal(model.ReturnUrl));
}
}
ModelState.AddErrors(result);
}
return(View(model));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var currentUser = await UserManager.FindByNameAsync(model.Email);
if (currentUser != null)
{
ModelState.AddModelError("",
"Вы уже зарегистрировались. Если пароль не подходит, нажмите «Забыли пароль?»");
return(View("Login", new LoginViewModel()
{
Email = model.Email
}));
}
var passValidateResult =
await UserManager.PasswordValidator.ValidateAsync(model.Password);
if (!passValidateResult.Succeeded)
{
ModelState.AddErrors(passValidateResult);
return(View(model));
}
var user = new JoinIdentityUser {
UserName = model.Email
};
var result = await UserManager.CreateAsync(user);
if (!result.Succeeded)
{
ModelState.AddErrors(result);
return(View(model));
}
//We don't want to sign in user until he has email confirmed
//await SignInManager.SignInAsync(user, isPersistent:false, rememberBrowser:false);
await UserManager.SetPasswordWithoutValidationAsync(user.Id, model.Password);
await SendConfirmationEmail(user);
return(View("RegisterSuccess"));
}
private async Task SendConfirmationEmail(JoinIdentityUser user)
{
var code = await UserManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Action("ConfirmEmail",
"Account",
new { userId = user.UserId, code },
protocol: Request.Scheme);
//TODO we need to reconsider interface for email service to unbound EmailService from User objects.
var dbUser = await UserRepository.GetById(user.UserId);
await _emailService.Email(new ConfirmEmail()
{
CallbackUrl = callbackUrl, Recipient = dbUser
});
}
public async Task <ActionResult> ExternalLoginConfirmation(
ExternalLoginConfirmationViewModel model,
string returnUrl)
{
if (User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index", "Manage"));
}
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await AuthenticationManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(View("ExternalLoginFailure"));
}
var user = new JoinIdentityUser()
{
UserName = 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 : true,
rememberBrowser : false);
return(RedirectToLocal(returnUrl));
}
}
ModelState.AddErrors(result);
}
ViewBag.ReturnUrl = returnUrl;
return(View(model));
}
public static Task <ClaimsIdentity> GenerateUserIdentityAsync(this JoinIdentityUser user,
UserManager <JoinIdentityUser, int> manager,
string authenticationType)
{
return(manager.ClaimsIdentityFactory.CreateAsync(manager, user, authenticationType));
}
