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)); }