public async Task <Result> Handle(Command request, CancellationToken ct)
{
request.ReturnUrl ??= "/";
var user = new User();
await _userStore.SetUserNameAsync(user, request.Email, ct);
await _emailStore.SetEmailAsync(user, request.Email, ct);
var result = await _userManager.CreateAsync(user, request.Password);
if (result.Succeeded)
{
await _mailer.SendLaterAsync(new AccountRegisteredMail(user));
await _userSession.LoginAsync(request.Email, request.Password);
}
else
{
throw new DomainException(result.Errors.Select(x => x.Description).Join(". "));
}
return(new Result
{
RedirectTo = request.ReturnUrl,
IdentityResult = result
});
}
public async Task <Result> Handle(Command request, CancellationToken ct)
{
request.ReturnUrl ??= "/";
var user = new User
{
Name = request.Name
};
await _userStore.SetUserNameAsync(user, request.Email, ct);
await _emailStore.SetEmailAsync(user, request.Email, ct);
var result = await _userManager.CreateAsync(user, request.Password);
if (result.Succeeded)
{
await _mailer.SendLaterAsync(new AccountRegisteredMail(user));
// TODO: configurable LoginAfterRegister?
// await _userSession.LoginAsync(request.Email, request.Password);
}
else
{
throw result.Errors.ToDomainException();
}
return(new Result
{
IdentityResult = result
});
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl ??= Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync())
.ToList();
if (ModelState.IsValid)
{
var user = CreateUser();
await _userStore.SetUserNameAsync(user, Input.Email, CancellationToken.None);
await _emailStore.SetEmailAsync(user, Input.Email, CancellationToken.None);
var result = await _userManager.CreateAsync(user, Input.Password);
// Add the email claim and value for this user.
await _userManager.AddClaimAsync(user, new Claim(ClaimTypes.Email, Input.Email));
// Remaining code removed for brevity.
#endregion
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = userId, code = code, returnUrl = returnUrl },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task <IActionResult> Index(RegisterViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = new User();
await _userStore.SetUserNameAsync(user, model.UserName, CancellationToken.None);
await _userEmailStore.SetEmailAsync(user, model.Email, CancellationToken.None);
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Action("Index", "ConfirmEmail", new
{
area = "",
userId, code
}, Request.Scheme);
await _emailSender.SendEmailAsync(new MailAddress(user.Email), "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = user.Email }));
}
await _signInManager.SignInAsync(user, isPersistent : false);
if (string.IsNullOrEmpty(model.ReturnUrl))
{
return(Redirect("/"));
}
return(LocalRedirect(model.ReturnUrl));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(View(model));
}
public async Task <IdentityResult> RegisterAsync(
TUser user,
string login,
string password = "",
CancellationToken ct = default)
{
await _userStore.SetUserNameAsync(user, login, ct);
await _emailStore.SetEmailAsync(user, login, ct);
if (string.IsNullOrEmpty(password))
{
return(await _userManager.CreateAsync(user));
}
return(await _userManager.CreateAsync(user, password));
}
public override 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(Redirect($"~/Identity/Account/Login?returnUrl={returnUrl}"));
}
if (ModelState.IsValid)
{
var user = CreateUser();
await _userStore.SetUserNameAsync(user, Input.Email, CancellationToken.None);
await _emailStore.SetEmailAsync(user, Input.Email, CancellationToken.None);
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);
returnUrl = returnUrl.StartsWith(Url.Content("~/")) ? returnUrl : Url.Content("~/" + returnUrl.Substring(1));
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
LoginProvider = info.LoginProvider;
ReturnUrl = returnUrl;
return(Page());
}
public virtual async Task <AuthResult> SetEmailAsync(TUser user, string email)
{
ThrowIfDisposed();
IUserEmailStore <TUser> emailStore = GetEmailStore();
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
await emailStore.SetEmailAsync(user, email, CancellationToken);
await emailStore.SetEmailConfirmedAsync(user, false, CancellationToken);
await UpdateSecurityStampInternal(user);
return(await UpdateUserAsync(user));
}
private async Task <IdentityResult> InitUserAsync(IdentityUser user, ExternalLoginInfo externalInfo)
{
var email = externalInfo.Principal.Identity.Name;
await _userStore.SetUserNameAsync(user, email, CancellationToken.None);
await _emailStore.SetEmailAsync(user, email, CancellationToken.None);
var result = await _userManager.CreateAsync(user);
var role = externalInfo.GetUserRole();
if (role != null)
{
await _userManager.AddToRoleAsync(user, role);
}
return(result);
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
// This part requires code modification.
// The account requested for sign up is stored in the cache server, and you must finally approve the subscription through e-mail authentication.
var user = CreateUser();
await _userStore.SetUserNameAsync(user, Input.Email, CancellationToken.None);
await _emailStore.SetEmailAsync(user, Input.Email, CancellationToken.None);
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = userId, code = code },
protocol: Request.Scheme);
//await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
// $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
return(Page());
}
public async Task <IActionResult> Register(RegisterModel model)
{
model.ReturnUrl = model.ReturnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var user = CreateUser();
await _userStore.SetUserNameAsync(user, model.Input.Email, CancellationToken.None);
await _emailStore.SetEmailAsync(user, model.Input.Email, CancellationToken.None);
var result = await _userManager.CreateAsync(user, model.Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = userId, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(model.Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(model.ReturnUrl));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(View());
}
public virtual async Task <AuthResult> ChangeEmailAsync(TUser user, string newEmail, string token)
{
ThrowIfDisposed();
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
// if (false)
// return AuthResult.Failed(ErrorDescriber.InvalidToken());
IUserEmailStore <TUser> emailStore = GetEmailStore();
await emailStore.SetEmailAsync(user, newEmail, CancellationToken);
await emailStore.SetEmailConfirmedAsync(user, true, CancellationToken);
await UpdateSecurityStampInternal(user);
return(await UpdateUserAsync(user));
}
public async Task <ActionResult> Create(InputModel newUser)
{
User user = Activator.CreateInstance <User>();
await userStore.SetUserNameAsync(user, newUser.Username, CancellationToken.None);
IUserEmailStore <User> emailStore = userStore as IUserEmailStore <User>;
await emailStore.SetEmailAsync(user, newUser.Email, CancellationToken.None);
AuthResult result = await userManager.CreateAsync(user, newUser.Password);
if (result.Succeeded)
{
logger.LogInformation(LoggerEventIds.UserCreated, "New user created!");
return(RedirectToAction("Index", "User"));
}
ViewData["Error"] = result.ToString();
return(View());
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
ReturnUrl = returnUrl;
if (ModelState.IsValid)
{
User user = Activator.CreateInstance <User>();
await UserStore.SetUserNameAsync(user, Input.Username, CancellationToken.None);
IUserEmailStore <User> emailStore = UserStore as IUserEmailStore <User>;
await emailStore.SetEmailAsync(user, Input.Email, CancellationToken.None);
AuthResult result = await UserManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
Logger.LogInformation(LoggerEventIds.UserCreated, "New user created!");
if (UserManager.Options.SignIn.RequireConfirmedAccount)
{
// DEV ONLY
await emailStore.SetEmailConfirmedAsync(user, true, CancellationToken.None);
await SignInManager.SignInAsync(user, false);
if (returnUrl == null)
{
return(LocalRedirect("~/"));
}
else
{
return(LocalRedirect(returnUrl));
}
}
}
}
return(Page());
}
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 = CreateUser();
await _userStore.SetUserNameAsync(user, Input.Email, CancellationToken.None);
await _emailStore.SetEmailAsync(user, Input.Email, CancellationToken.None);
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 props = new AuthenticationProperties();
props.StoreTokens(info.AuthenticationTokens);
props.IsPersistent = true;
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = userId, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(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(RedirectToPage("./RegisterConfirmation", new { Email = 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);
}
}
ProviderDisplayName = info.ProviderDisplayName;
ReturnUrl = returnUrl;
return(Page());
}
public override async Task <IDisplayResult> UpdateAsync(User user, UpdateEditorContext context)
{
var model = new EditUserViewModel();
if (!await context.Updater.TryUpdateModelAsync(model, Prefix))
{
return(await EditAsync(user, context));
}
model.UserName = model.UserName?.Trim();
model.Email = model.Email?.Trim();
user.EmailConfirmed = model.EmailConfirmed;
if (string.IsNullOrWhiteSpace(model.UserName))
{
context.Updater.ModelState.AddModelError("UserName", T["A user name is required."]);
}
if (string.IsNullOrWhiteSpace(model.Email))
{
context.Updater.ModelState.AddModelError("Email", T["An email is required."]);
}
await _userStore.SetUserNameAsync(user, model.UserName, default(CancellationToken));
await _userEmailStore.SetEmailAsync(user, model.Email, default(CancellationToken));
var userWithSameName = await _userStore.FindByNameAsync(_userManager.NormalizeKey(model.UserName), default(CancellationToken));
if (userWithSameName != null)
{
var userWithSameNameId = await _userStore.GetUserIdAsync(userWithSameName, default(CancellationToken));
if (userWithSameNameId != model.Id)
{
context.Updater.ModelState.AddModelError(string.Empty, T["The user name is already used."]);
}
}
var userWithSameEmail = await _userEmailStore.FindByEmailAsync(_userManager.NormalizeKey(model.Email), default(CancellationToken));
if (userWithSameEmail != null)
{
var userWithSameEmailId = await _userStore.GetUserIdAsync(userWithSameEmail, default(CancellationToken));
if (userWithSameEmailId != model.Id)
{
context.Updater.ModelState.AddModelError(string.Empty, T["The email is already used."]);
}
}
if (context.Updater.ModelState.IsValid)
{
var roleNames = model.Roles.Where(x => x.IsSelected).Select(x => x.Role).ToList();
if (context.IsNew)
{
// Add new roles
foreach (var role in roleNames)
{
await _userRoleStore.AddToRoleAsync(user, _userManager.NormalizeKey(role), default(CancellationToken));
}
}
else
{
// Remove roles in two steps to prevent an iteration on a modified collection
var rolesToRemove = new List <string>();
foreach (var role in await _userRoleStore.GetRolesAsync(user, default(CancellationToken)))
{
if (!roleNames.Contains(role))
{
rolesToRemove.Add(role);
}
}
foreach (var role in rolesToRemove)
{
await _userRoleStore.RemoveFromRoleAsync(user, _userManager.NormalizeKey(role), default(CancellationToken));
}
// Add new roles
foreach (var role in roleNames)
{
if (!await _userRoleStore.IsInRoleAsync(user, _userManager.NormalizeKey(role), default(CancellationToken)))
{
await _userRoleStore.AddToRoleAsync(user, _userManager.NormalizeKey(role), default(CancellationToken));
}
}
}
}
return(await EditAsync(user, context));
}
public async Task <IActionResult> SignInCompleteAsync()
{
string returnUrl = "/";
//returnUrl = returnUrl ?? "/";
var info = await SignInManager.GetExternalLoginInfoAsync();
if (info == null)
{
// El login no es válido o no se ha completado
return(BadRequest());
}
//var userid = info.Principal.Claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier);
//var name = info.Principal.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Name);
//var identityAtDb = await UserManager.FindByLoginAsync(info.LoginProvider, info.ProviderKey);
//if (identityAtDb == null)
//{
// identityAtDb = await UserManager.FindByEmailAsync(email);
// if(identityAtDb == null)
// {
// identityAtDb = new MyUser();
// identityAtDb.Email = email;
// }
//}
//var userAtIdentity = await UserManager.FindByEmailAsync
var result = await SignInManager.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, isPersistent : false, bypassTwoFactor : true);
if (result.Succeeded)
{
return(Ok());
}
if (result.IsLockedOut)
{
return(Forbid());
}
else
{
// La idea es: si el usuario no tiene una cuenta creada y enlazada con el proveedor (hubiera pasado por result.Succeeded)
// exijimos (si aplica) que se cree una cuenta.
// Podemos coger los Claims que nos provee el servicio externo.
var email = info.Principal.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Email)?.Value;
if (string.IsNullOrWhiteSpace(email))
{
return(SignOut());
}
var identityUser = new MyUser();
await UserStore.SetUserNameAsync(identityUser, email, System.Threading.CancellationToken.None);
await EmailStore.SetEmailAsync(identityUser, email, System.Threading.CancellationToken.None);
var createResult = await UserManager.CreateAsync(identityUser);
if (createResult.Succeeded)
{
await SignInManager.SignInAsync(identityUser, isPersistent : false);
return(Redirect("/"));
}
else
{
foreach (var error in createResult.Errors)
{
ModelState.AddModelError(error.Code, error.Description);
}
return(BadRequest(ModelState));
}
}
}