public virtual void CanAddAndFindByUserId()
{
using (var uow = DataService.StartUnitOfWork())
{
var user = new IdentityUserEntity
{
Identifier = Guid.NewGuid(),
Name = "Achim Schnell",
NormalizedName = "ACHIM SCHNELL",
Email = "*****@*****.**",
NormalizedEmail = "*****@*****.**",
AccessFailedCount = 0,
ApplicationId = 0,
EmailConfirmed = true,
IsAnonymous = false,
LastActivityDate = DateTime.Now
};
uow.UserRepository.Add(user);
var login = new IdentityUserLoginEntity
{
UserId = user.Identifier,
ProviderName = "Google",
ProviderKey = "MyKey",
ProviderDisplayName = null
};
uow.LoginRepository.Add(login);
Assert.AreEqual(login.ProviderKey,
uow.LoginRepository.FindByUserId(user.Identifier).Single().ProviderKey);
}
}
/// <summary> Gets by user. </summary>
/// <param name="user"> The user. </param>
/// <returns> The by user. </returns>
public virtual IEnumerable <IdentityClaimEntity> GetByUser(IdentityUserEntity user)
{
var command = SqlBuilder.SelectByFilter(EntityType, nameof(IdentityClaimEntity.UserId));
return(UnitOfWork.Connection.Query <IdentityClaimEntity>(command, new { UserId = user.Id },
UnitOfWork.Transaction));
}
/// <summary>Registers the first user admin without confirmation.</summary>
/// <param name="uow"> The uow. </param>
/// <param name="model"> The model. </param>
/// <param name="returnUrl"> URL of the return. </param>
/// <returns>The asynchronous result that yields an IdentityUserEntity.</returns>
private async Task <IdentityUserEntity> RegisterFirstUserAdminWithoutConfirmation(IIdentityUnitOfWork uow, RegisterViewModel model, string returnUrl)
{
var admin = uow.RoleRepository.FindByLoweredName("ADMINISTRATOR") ?? uow.RoleRepository.Add(
new IdentityRoleEntity
{
ApplicationId = 0,
Description = "Administrator-Role",
Identifier = Guid.NewGuid(),
NormalizedName = "ADMINISTRATOR",
Name = "Administrator"
});
uow.Commit();
var user = new IdentityUserEntity {
Name = model.Name, Email = model.Email, Phone = model.Phone
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, admin.Name);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
await _userManager.ConfirmEmailAsync(user, code);
}
return(user);
}
public virtual void CanDeleteClaim()
{
using (var uow = DataService.StartUnitOfWork())
{
var user = new IdentityUserEntity
{
Identifier = Guid.NewGuid(),
Name = "Achim Schnell",
NormalizedName = "ACHIM SCHNELL",
Email = "*****@*****.**",
NormalizedEmail = "*****@*****.**",
AccessFailedCount = 0,
ApplicationId = 0,
EmailConfirmed = true,
IsAnonymous = false,
LastActivityDate = DateTime.Now
};
uow.UserRepository.Add(user);
var claim = new IdentityClaimEntity
{
UserId = user.Id,
Type = "Age",
Value = "18"
};
uow.ClaimRepository.Add(claim);
uow.ClaimRepository.Delete(claim);
Assert.AreEqual(null, uow.ClaimRepository.Get(claim.Id));
}
}
/// <summary> Finds the users in this collection. </summary>
/// <param name="user"> The user. </param>
/// <returns>
/// An enumerator that allows foreach to be used to process the users in this collection.
/// </returns>
public virtual IEnumerable <int> FindByUser(IdentityUserEntity user)
{
var command = SqlBuilder.SelectByFilter(EntityType, nameof(IdentityUserRoleEntity.UserId),
new[] { nameof(IdentityUserRoleEntity.RoleId) });
return(UnitOfWork.Connection.Query <int>(command, new { UserId = user.Id },
UnitOfWork.Transaction));
}
/// <summary> Gets by user and type. </summary>
/// <param name="user"> The user. </param>
/// <param name="claimType"> Type of the claim. </param>
/// <returns> The by user and type. </returns>
public virtual IdentityClaimEntity GetByUserAndType(IdentityUserEntity user, string claimType)
{
var command = SqlBuilder.SelectByFilter(EntityType,
new[] { nameof(IdentityClaimEntity.Type), nameof(IdentityClaimEntity.UserId) });
return(UnitOfWork.Connection.QuerySingleOrDefault <IdentityClaimEntity>(command,
new { Type = claimType, UserId = user.Id },
UnitOfWork.Transaction));
}
public virtual void CanUpdateUserRole()
{
using (var uow = DataService.StartUnitOfWork())
{
var user = new IdentityUserEntity
{
Identifier = Guid.NewGuid(),
Name = "Achim Schnell",
NormalizedName = "ACHIM SCHNELL",
Email = "*****@*****.**",
NormalizedEmail = "*****@*****.**",
AccessFailedCount = 0,
ApplicationId = 0,
EmailConfirmed = true,
IsAnonymous = false,
LastActivityDate = DateTime.Now
};
uow.UserRepository.Add(user);
var user2 = new IdentityUserEntity
{
Identifier = Guid.NewGuid(),
Name = "Stefan Schnell",
NormalizedName = "STEFAN SCHNELL",
Email = "*****@*****.**",
NormalizedEmail = "*****@*****.**",
AccessFailedCount = 0,
ApplicationId = 0,
EmailConfirmed = true,
IsAnonymous = false,
LastActivityDate = DateTime.Now
};
uow.UserRepository.Add(user2);
var role = new IdentityRoleEntity
{
Identifier = Guid.NewGuid(),
Name = "DummyRole",
ApplicationId = 0,
Description = "DummyRole",
NormalizedName = "dummyrole"
};
uow.RoleRepository.Add(role);
var userRole = new IdentityUserRoleEntity
{
UserId = user.Id,
RoleId = role.Id
};
userRole = uow.UserRoleRepository.Add(userRole);
userRole.UserId = user2.Id;
uow.UserRoleRepository.Update(userRole);
Assert.AreEqual(userRole.UserId, uow.UserRoleRepository.Get(userRole.Id).UserId);
}
}
private async Task LoadAsync(IdentityUserEntity user)
{
var email = await _userManager.GetEmailAsync(user);
Email = email;
Input = new InputModel
{
NewEmail = email,
};
IsEmailConfirmed = await _userManager.IsEmailConfirmedAsync(user);
}
private async Task LoadAsync(IdentityUserEntity 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 ??= Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new IdentityUserEntity {
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 <IEnumerable <Claim> > GetClaimsFromUser(IdentityUserEntity user)
{
var claims = new List <Claim>
{
new Claim(JwtClaimTypes.Subject, user.Identifier.ToString()),
new Claim("identifier", user.Identifier.ToString()),
new Claim(JwtClaimTypes.Name, user.Name)
};
if (_userManager.SupportsUserEmail)
{
claims.AddRange(new[]
{
new Claim(JwtClaimTypes.Email, user.Email),
new Claim(JwtClaimTypes.EmailVerified, user.EmailConfirmed ? "true" : "false",
ClaimValueTypes.Boolean)
});
}
if (_userManager.SupportsUserPhoneNumber)
{
claims.AddRange(new[]
{
new Claim(JwtClaimTypes.PhoneNumber, user.Phone),
new Claim(JwtClaimTypes.PhoneNumberVerified, user.PhoneConfirmed ? "true" : "false",
ClaimValueTypes.Boolean)
});
}
if (_userManager.SupportsUserClaim)
{
claims.AddRange(await _userManager.GetClaimsAsync(user));
}
if (!_userManager.SupportsUserRole)
{
return(claims);
}
var roles = await _userManager.GetRolesAsync(user);
claims.AddRange(roles.Select(role => new Claim(JwtClaimTypes.Role, role)));
return(claims);
}
/// <summary>Sends a confirmation mail.</summary>
/// <param name="user"> The user. </param>
private async Task SendConfirmationMail(IdentityUserEntity user)
{
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Action(nameof(ConfirmEmail), "Account", new { userId = user.Identifier, code },
HttpContext.Request.Scheme);
if (_adminOptions.ConfirmationRecipient == MailAddressConfirmationRecipient.User)
{
await _emailSender.SendEmailAsync(user.Email,
new UserConfirmMailModel(_localizerFactory, _applicationOptions, user.Email, callbackUrl));
}
else
{
await _emailSender.SendEmailAsync(_adminOptions.AdminConfirmationRecipient,
new AdminConfirmMailModel(_localizerFactory, _applicationOptions, callbackUrl, _adminOptions.AdminConfirmationRecipient, Url.Action(nameof(AdminController.ManageUser), "Admin", new { userId = user.Id }, HttpContext.Request.Scheme)));
}
}
public async Task <IActionResult> Register(RegisterViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
using (var uow = _identityDataService.StartUnitOfWork())
{
if (uow.UserRepository.Count() == 0)
{
var admin = await RegisterFirstUserAdminWithoutConfirmation(uow, model, returnUrl);
if (admin == null)
{
return(View(model));
}
await _signInManager.SignInAsync(admin, false);
return(RedirectToLocal(returnUrl));
}
}
var user = new IdentityUserEntity {
Name = model.Name, Email = model.Email, Phone = model.Phone
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SendConfirmationMail(user);
// sign the user in
// disabled to force the the user to confirm his mail address
//await _signInManager.SignInAsync(user, isPersistent: false);
_logger.LogInformation(3, "User created a new account with password.");
return(RedirectToAction(nameof(ConfirmEmailNotification)));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public virtual void CanFindByNameAndKey()
{
using (var uow = DataService.StartUnitOfWork())
{
var user = new IdentityUserEntity
{
Identifier = Guid.NewGuid(),
Name = "Achim Schnell",
NormalizedName = "ACHIM SCHNELL",
Email = "*****@*****.**",
NormalizedEmail = "*****@*****.**",
AccessFailedCount = 0,
ApplicationId = 0,
EmailConfirmed = true,
IsAnonymous = false,
LastActivityDate = DateTime.Now
};
uow.UserRepository.Add(user);
var logins = new[]
{
new IdentityUserLoginEntity
{
UserId = user.Identifier,
ProviderName = "Google",
ProviderKey = "askljökadöäsadFKÖÄ'sadasasd",
ProviderDisplayName = null
},
new IdentityUserLoginEntity
{
UserId = user.Identifier,
ProviderName = "Google",
ProviderKey = "MyKey",
ProviderDisplayName = null
}
};
uow.LoginRepository.AddRange(logins);
var entity = uow.LoginRepository.FindByNameAndKey("Google", "MyKey");
Assert.IsNotNull(entity);
}
}
public virtual void CanGetClaimsByType()
{
using (var uow = DataService.StartUnitOfWork())
{
var user = new IdentityUserEntity
{
Identifier = Guid.NewGuid(),
Name = "Achim Schnell",
NormalizedName = "ACHIM SCHNELL",
Email = "*****@*****.**",
NormalizedEmail = "*****@*****.**",
AccessFailedCount = 0,
ApplicationId = 0,
EmailConfirmed = true,
IsAnonymous = false,
LastActivityDate = DateTime.Now
};
uow.UserRepository.Add(user);
var claims = new[]
{
new IdentityClaimEntity
{
UserId = user.Id,
Type = "Age",
Value = "18"
},
new IdentityClaimEntity
{
UserId = user.Id,
Type = "Sex",
Value = "male"
}
};
uow.ClaimRepository.AddRange(claims);
Assert.AreEqual(claims.Single(c => c.Type == "Sex").UserId,
uow.ClaimRepository.GetUserIdsForClaimType("Sex").Single());
}
}
public virtual void CanAddAndFindByNormalizedEmail()
{
using (var uow = DataService.StartUnitOfWork())
{
var user = new IdentityUserEntity
{
Identifier = Guid.NewGuid(),
Name = "Achim Schnell",
NormalizedName = "ACHIM SCHNELL",
Email = "*****@*****.**",
NormalizedEmail = "*****@*****.**",
AccessFailedCount = 0,
ApplicationId = 0,
EmailConfirmed = true,
IsAnonymous = false,
LastActivityDate = DateTime.Now
};
uow.UserRepository.Add(user);
Assert.AreEqual(user.Name, uow.UserRepository.FindByNormalizedEmail(user.NormalizedEmail).Name);
}
}
public async Task <IActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model,
string returnUrl = null)
{
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(View("ExternalLoginFailure"));
}
var user = new IdentityUserEntity {
Name = model.Name, Email = model.Email
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
await SendConfirmationMail(user);
// disabled to force the the user to confirm his mail address
// await _signInManager.SignInAsync(user, isPersistent: false);
_logger.LogInformation(6, "User created an account using {Name} provider.", info.LoginProvider);
return(RedirectToAction(nameof(ConfirmEmailNotification)));
}
}
AddErrors(result);
}
ViewData["ReturnUrl"] = returnUrl;
return(View(model));
}
/// <summary>
/// Gets by user and type.
/// </summary>
/// <param name="user"> The user. </param>
/// <param name="claimType"> Type of the claim. </param>
/// <returns>
/// The by user and type.
/// </returns>
public IdentityClaimEntity GetByUserAndType(IdentityUserEntity user, string claimType)
{
return(Collection.Find(e => e.UserId == user.Id && e.Type == claimType).SingleOrDefault());
}
/// <summary>
/// Gets by user.
/// </summary>
/// <param name="user"> The user. </param>
/// <returns>
/// The by user.
/// </returns>
public IEnumerable <IdentityClaimEntity> GetByUser(IdentityUserEntity user)
{
return(Collection.Find(e => e.UserId == user.Id));
}
/// <summary>
/// Searches for the first user.
/// </summary>
/// <param name="user"> The user. </param>
/// <returns>
/// The found user.
/// </returns>
public IEnumerable <int> FindByUser(IdentityUserEntity user)
{
return(Collection.Find(e => e.UserId == user.Id).Select(e => e.RoleId));
}
