public async Task <IdentityResult> CreateNewAccount(RegistrationRequest model)
{
var newUser = new MonsterUser
{
Id = model.UserName,
UserName = model.UserName,
EmailConfirmed = false
};
newUser.PasswordHash = new PasswordHasher <MonsterUser>().HashPassword(newUser, model.Password);
var result = await _userManager.CreateAsync(newUser).ConfigureAwait(false);
MonsterUser identityUser = await _userManager.FindByIdAsync(model.UserName).ConfigureAwait(false);
var claims = new List <Claim>()
{
new Claim(JwtClaimTypes.GivenName, model.FirstName),
new Claim(JwtClaimTypes.FamilyName, model.LastName),
new Claim(CustomClaimTypes.TentclesClaim, model.Tentacles.ToString()),
new Claim(CustomClaimTypes.StartedScaringClaim, DateTime.Today.Date.ToString("yyyy-MM-dd")),
new Claim(JwtClaimTypes.PhoneNumber, model.Phone),
new Claim(CustomClaimTypes.Username, model.UserName),
};
return(await _userManager.AddClaimsAsync(identityUser, claims));
}
FindUserFromExternalProviderAsync(AuthenticateResult result)
{
var externalUser = result.Principal;
// try to determine the unique id of the external user (issued by the provider)
// the most common claim type for that are the sub claim and the NameIdentifier
// depending on the external provider, some other claim type might be used
var userIdClaim = externalUser.FindFirst(JwtClaimTypes.Subject) ??
externalUser.FindFirst(ClaimTypes.NameIdentifier) ??
throw new Exception("Unknown userid");
// remove the user id claim so we don't include it as an extra claim if/when we provision the user
var claims = externalUser.Claims.ToList();
claims.Remove(userIdClaim);
var provider = result.Properties.Items["scheme"];
var providerUserId = userIdClaim.Value;
// find external user
var user = await _userManager.FindByLoginAsync(provider, providerUserId);
// try to find user by name and/or email
if (user == null)
{
var name = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.Name)?.Value ?? claims.FirstOrDefault(x => x.Type == ClaimTypes.Name)?.Value;
if (name != null)
{
user = await _userManager.FindByNameAsync(name);
}
if (user == null)
{
var prefname = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.PreferredUserName)?.Value;
if (prefname != null)
{
user = await _userManager.FindByNameAsync(prefname);
}
}
if (user == null)
{
var email = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.Email)?.Value ?? claims.FirstOrDefault(x => x.Type == ClaimTypes.Email)?.Value;
if (email != null)
{
user = await _userManager.FindByEmailAsync(email);
}
}
if (user != null)
{
var identityResult = await _userManager.AddLoginAsync(user, new UserLoginInfo(provider, providerUserId, provider));
if (!identityResult.Succeeded)
{
throw new Exception(identityResult.Errors.First().Description);
}
}
}
return(user, provider, providerUserId, claims);
}
private async Task LoadAsync(MonsterUser user)
{
var email = await _userManager.GetEmailAsync(user);
Email = email;
Input = new InputModel
{
NewEmail = email,
};
IsEmailConfirmed = await _userManager.IsEmailConfirmedAsync(user);
}
private async Task LoadAsync(MonsterUser user)
{
var userName = await _userManager.GetUserNameAsync(user);
var phoneNumber = await _userManager.GetPhoneNumberAsync(user);
Username = userName;
Input = new InputModel
{
PhoneNumber = phoneNumber
};
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new MonsterUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
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 = user.Id, 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());
}
private async Task LoadSharedKeyAndQrCodeUriAsync(MonsterUser user)
{
// Load the authenticator key & QR code URI to display on the form
var unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
if (string.IsNullOrEmpty(unformattedKey))
{
await _userManager.ResetAuthenticatorKeyAsync(user);
unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
}
SharedKey = FormatKey(unformattedKey);
var email = await _userManager.GetEmailAsync(user);
AuthenticatorUri = GenerateQrCodeUri(email, unformattedKey);
}
public static void Seed(this IdentityDbContext dbcontext, ModelBuilder builder)
{
var password = "******";
var james = new MonsterUser
{
Id = "1",
UserName = "******",
NormalizedUserName = "******",
PhoneNumber = "09-102023993",
EmailConfirmed = false
};
james.PasswordHash = new PasswordHasher <MonsterUser>().HashPassword(james, password);
//Michael "Mike" Wazowski
var mike = new MonsterUser
{
Id = "2",
UserName = "******",
NormalizedUserName = "******",
EmailConfirmed = false
};
mike.PasswordHash = new PasswordHasher <MonsterUser>().HashPassword(mike, password);
builder.Entity <MonsterUser>()
.HasData(james, mike);
builder.Entity <IdentityUserClaim <string> >()
.HasData(
new IdentityUserClaim <string>
{
Id = 1,
UserId = "1",
ClaimType = "name",
ClaimValue = "James Sullivan"
},
new IdentityUserClaim <string>
{
Id = 2,
UserId = "1",
ClaimType = JwtClaimTypes.GivenName,
ClaimValue = "James"
},
new IdentityUserClaim <string>
{
Id = 3,
UserId = "1",
ClaimType = JwtClaimTypes.FamilyName,
ClaimValue = "Sullivan"
},
new IdentityUserClaim <string>
{
Id = 4,
UserId = "1",
ClaimType = CustomClaimTypes.TentclesClaim,
ClaimValue = "11"
},
new IdentityUserClaim <string>
{
Id = 5,
UserId = "1",
ClaimType = CustomClaimTypes.StartedScaringClaim,
ClaimValue = "1990-10-22"
},
new IdentityUserClaim <string>
{
Id = 6,
UserId = "1",
ClaimType = JwtClaimTypes.PhoneNumber,
ClaimValue = "0543300922"
},
new IdentityUserClaim <string>
{
Id = 7,
UserId = "2",
ClaimType = "name",
ClaimValue = "Mike Wazowski"
},
new IdentityUserClaim <string>
{
Id = 8,
UserId = "2",
ClaimType = JwtClaimTypes.GivenName,
ClaimValue = "Mike"
},
new IdentityUserClaim <string>
{
Id = 9,
UserId = "2",
ClaimType = JwtClaimTypes.FamilyName,
ClaimValue = "Wazowski"
},
new IdentityUserClaim <string>
{
Id = 10,
UserId = "2",
ClaimType = CustomClaimTypes.TentclesClaim,
ClaimValue = "2"
},
new IdentityUserClaim <string>
{
Id = 11,
UserId = "2",
ClaimType = CustomClaimTypes.StartedScaringClaim,
ClaimValue = "2019-10-22"
},
new IdentityUserClaim <string>
{
Id = 12,
UserId = "1",
ClaimType = "location",
ClaimValue = "somewhere"
},
new IdentityUserClaim <string>
{
Id = 13,
UserId = "2",
ClaimType = "location",
ClaimValue = "somewhere else"
},
new IdentityUserClaim <string>
{
Id = 14,
UserId = "1",
ClaimType = CustomClaimTypes.Username,
ClaimValue = "james"
},
new IdentityUserClaim <string>
{
Id = 15,
UserId = "2",
ClaimType = CustomClaimTypes.Username,
ClaimValue = "mike"
});
}
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 MonsterUser {
UserName = Input.Email, Email = 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.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());
}
private async Task <MonsterUser> AutoProvisionUserAsync(string provider, string providerUserId, IEnumerable <Claim> claims)
{
// create a list of claims that we want to transfer into our store
var filtered = new List <Claim>();
// user's display name
var name = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.Name)?.Value ??
claims.FirstOrDefault(x => x.Type == ClaimTypes.Name)?.Value;
if (name != null)
{
filtered.Add(new Claim(JwtClaimTypes.Name, name));
}
else
{
var first = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.GivenName)?.Value ??
claims.FirstOrDefault(x => x.Type == ClaimTypes.GivenName)?.Value;
var last = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.FamilyName)?.Value ??
claims.FirstOrDefault(x => x.Type == ClaimTypes.Surname)?.Value;
if (first != null && last != null)
{
filtered.Add(new Claim(JwtClaimTypes.Name, first + " " + last));
}
else if (first != null)
{
filtered.Add(new Claim(JwtClaimTypes.Name, first));
}
else if (last != null)
{
filtered.Add(new Claim(JwtClaimTypes.Name, last));
}
}
// email
var email = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.Email)?.Value ??
claims.FirstOrDefault(x => x.Type == ClaimTypes.Email)?.Value;
if (email != null)
{
filtered.Add(new Claim(JwtClaimTypes.Email, email));
}
var user = new MonsterUser
{
UserName = Guid.NewGuid().ToString(),
};
var identityResult = await _userManager.CreateAsync(user);
if (!identityResult.Succeeded)
{
throw new Exception(identityResult.Errors.First().Description);
}
if (filtered.Any())
{
identityResult = await _userManager.AddClaimsAsync(user, filtered);
if (!identityResult.Succeeded)
{
throw new Exception(identityResult.Errors.First().Description);
}
}
identityResult = await _userManager.AddLoginAsync(user, new UserLoginInfo(provider, providerUserId, provider));
if (!identityResult.Succeeded)
{
throw new Exception(identityResult.Errors.First().Description);
}
return(user);
}
