public IdentityUserManager( IdentityUserStore store, IIdentityRoleRepository roleRepository, IIdentityUserRepository userRepository, IOptions <IdentityOptions> optionsAccessor, IPasswordHasher <IdentityUser> passwordHasher, IEnumerable <IUserValidator <IdentityUser> > userValidators, IEnumerable <IPasswordValidator <IdentityUser> > passwordValidators, IdentityUserOrganizationUnitRepository userOrganizationUnitRepository, ILookupNormalizer keyNormalizer, IdentityErrorDescriber errors, IServiceProvider services, ILogger <IdentityUserManager> logger, ICancellationTokenProvider cancellationTokenProvider) : base( store, optionsAccessor, passwordHasher, userValidators, passwordValidators, keyNormalizer, errors, services, logger) { RoleRepository = roleRepository; UserOrganizationUnitRepository = userOrganizationUnitRepository; UserRepository = userRepository; CancellationTokenProvider = cancellationTokenProvider; }
public WeixinAppService( IGuidGenerator guidGenerator, IConfiguration configuration, IHttpClientFactory httpClientFactory, IPasswordHasher <IdentityUser> passwordHasher, ICurrentTenant currentTenant, ISettingProvider setting, WeixinManager weixinManager, IdentityUserStore identityUserStore, ICapPublisher capBus, IUnitOfWorkManager unitOfWorkManager, IAppProvider appProvider, IWeixinApi weixinApi) { ObjectMapperContext = typeof(WeixinModule); _guidGenerator = guidGenerator; _configuration = configuration; _httpClientFactory = httpClientFactory; _passwordHasher = passwordHasher; _currentTenant = currentTenant; _setting = setting; _weixinManager = weixinManager; _identityUserStore = identityUserStore; _capBus = capBus; _unitOfWorkManager = unitOfWorkManager; _appProvider = appProvider; _weixinApi = weixinApi; }
public async Task DeleteAsync_should_delete_user() { using var documentStore = new RavenDbTestDriverWrapper().GetDocumentStore(); var services = new ServiceCollection() .AddLogging(); services.AddIdentity <IdentityUser, IdentityRole>() .AddRavenDbStores(p => documentStore); IServiceProvider provider = services.AddIdentityServer4AdminRavenDbkStores <IdentityUser, IdentityRole>(p => documentStore).BuildServiceProvider(); using var scope = provider.CreateScope(); provider = scope.ServiceProvider; var userManager = provider.GetRequiredService <UserManager <IdentityUser> >(); var user = new IdentityUser { Id = Guid.NewGuid().ToString(), Email = "*****@*****.**", EmailConfirmed = true, UserName = Guid.NewGuid().ToString() }; var result = await userManager.CreateAsync(user); Assert.True(result.Succeeded); var sut = new IdentityUserStore <IdentityUser>(userManager, new ScopedAsynDocumentcSession(documentStore.OpenAsyncSession()), provider.GetRequiredService <ILogger <IdentityUserStore <IdentityUser> > >()); await sut.DeleteAsync(user.Id); var actual = await userManager.FindByIdAsync(user.Id); Assert.Null(actual); }
public ApplicationUserManager(IdentityUserStore store, IDataProtectionProvider dataProtectionProvider) : base(store) { this.UserValidator = new UserValidator <User>(this) { AllowOnlyAlphanumericUserNames = false, RequireUniqueEmail = true }; this.PasswordValidator = new PasswordValidator { RequiredLength = 6 }; this.UserLockoutEnabledByDefault = true; this.DefaultAccountLockoutTimeSpan = TimeSpan.FromMinutes(5); this.MaxFailedAccessAttemptsBeforeLockout = 5; this.RegisterTwoFactorProvider("Email Code", new EmailTokenProvider <User> { Subject = "Security Code", BodyFormat = "Your security code is {0}" }); this.EmailService = new EmailSenderProvider(); #if !DEBUG_TEST if (dataProtectionProvider != null) { IDataProtector dataProtector = dataProtectionProvider.Create("ASP.NET Identity"); this.UserTokenProvider = new DataProtectorTokenProvider <User>(dataProtector); } #endif }
public async Task CreateAsync_should_create_user() { using var documentStore = new RavenDbTestDriverWrapper().GetDocumentStore(); var services = new ServiceCollection() .AddLogging(); services.AddIdentity <IdentityUser, IdentityRole>() .AddRavenDbStores(p => documentStore); IServiceProvider provider = services.AddIdentityServer4AdminRavenDbkStores <IdentityUser, IdentityRole>(p => documentStore).BuildServiceProvider(); using var scope = provider.CreateScope(); provider = scope.ServiceProvider; var userManager = provider.GetRequiredService <UserManager <IdentityUser> >(); var sut = new IdentityUserStore <IdentityUser>(userManager, new ScopedAsynDocumentcSession(documentStore.OpenAsyncSession()), provider.GetRequiredService <ILogger <IdentityUserStore <IdentityUser> > >()); var result = await sut.CreateAsync(new Entity.User { Email = "*****@*****.**", UserName = Guid.NewGuid().ToString() } as object); Assert.NotNull(result); Assert.NotNull(((Entity.User)result).Id); }
public WeixinAppService( IGuidGenerator guidGenerator, IConfiguration configuration, IHttpClientFactory httpClientFactory, IPasswordHasher <IdentityUser> passwordHasher, ICurrentTenant currentTenant, ISettingProvider setting, WeixinManager weixinManager, IdentityUserStore identityUserStore, ICapPublisher capBus, IUserClaimsPrincipalFactory <IdentityUser> principalFactory, IdentityServerOptions options, IHttpContextAccessor httpContextAccessor, ITokenService TS, IUnitOfWorkManager unitOfWorkManager, IAppProvider appProvider ) { ObjectMapperContext = typeof(WeixinModule); _guidGenerator = guidGenerator; _configuration = configuration; _httpClientFactory = httpClientFactory; _passwordHasher = passwordHasher; _currentTenant = currentTenant; _setting = setting; _weixinManager = weixinManager; _identityUserStore = identityUserStore; _capBus = capBus; _principalFactory = principalFactory; _options = options; _httpContextAccessor = httpContextAccessor; _ts = TS; _unitOfWorkManager = unitOfWorkManager; _appProvider = appProvider; }
public IdentityUserStore_Tests() { _identityUserStore = GetRequiredService <IdentityUserStore>(); _lookupNormalizer = GetRequiredService <ILookupNormalizer>(); _userRepository = GetRequiredService <IIdentityUserRepository>(); _testData = GetRequiredService <IdentityTestData>(); _unitOfWorkManager = GetRequiredService <IUnitOfWorkManager>(); }
public IdentityUserAppService( IdentityUserManager userManager, IIdentityUserRepository userRepository, IUserEmailer userEmailer, IStringEncryptionService encryptionService, IdentityUserStore identityUserStore) { _userManager = userManager; _userRepository = userRepository; _userEmailer = userEmailer; _encryptionService = encryptionService; _identityUserStore = identityUserStore; }
public HomeController(ISettingProvider setting, IdentityUserStore identityUserStore, IRedisClient redisClient, IdentityUserManager userManager) { _setting = setting; _identityUserStore = identityUserStore; _redisClient = redisClient; _userManager = userManager; }
public IdentityUserManager(IdentityUserStore store, IOptions <IdentityOptions> optionsAccessor, IPasswordHasher <User> passwordHasher, IEnumerable <IdentityUserValidator> userValidators, IEnumerable <IPasswordValidator <User> > passwordValidators, ILookupNormalizer keyNormalizer, IdentityErrorDescriber errors, IServiceProvider services, ILogger <UserManager <User> > logger) : base(store, optionsAccessor, passwordHasher, userValidators, passwordValidators, keyNormalizer, errors, services, logger) { }
public async Task GetAsync_by_id_should_expand_claims_and_roles() { using var documentStore = new RavenDbTestDriverWrapper().GetDocumentStore(); var services = new ServiceCollection() .AddLogging(); services.AddIdentity <IdentityUser, IdentityRole>() .AddRavenDbStores(p => documentStore); IServiceProvider provider = services.AddIdentityServer4AdminRavenDbkStores <IdentityUser, IdentityRole>(p => documentStore).BuildServiceProvider(); using var scope = provider.CreateScope(); provider = scope.ServiceProvider; var userManager = provider.GetRequiredService <UserManager <IdentityUser> >(); var user = new IdentityUser { Id = Guid.NewGuid().ToString(), Email = "*****@*****.**", EmailConfirmed = true, UserName = Guid.NewGuid().ToString() }; var userResult = await userManager.CreateAsync(user); Assert.True(userResult.Succeeded); await userManager.AddClaimsAsync(user, new[] { new Claim(Guid.NewGuid().ToString(), Guid.NewGuid().ToString()) }).ConfigureAwait(false); var roleManager = provider.GetRequiredService <RoleManager <IdentityRole> >(); var roleName = Guid.NewGuid().ToString(); await roleManager.CreateAsync(new IdentityRole { Id = Guid.NewGuid().ToString(), Name = roleName }).ConfigureAwait(false); await userManager.AddToRoleAsync(user, roleName).ConfigureAwait(false); var sut = new IdentityUserStore <IdentityUser>(userManager, new ScopedAsynDocumentcSession(documentStore.OpenAsyncSession()), provider.GetRequiredService <ILogger <IdentityUserStore <IdentityUser> > >()); var result = await sut.GetAsync(user.Id, new GetRequest { Expand = $"{nameof(Entity.User.UserClaims)},{nameof(Entity.User.UserRoles)}" }); Assert.NotNull(result); Assert.Single(result.UserClaims); Assert.Single(result.UserRoles); }
public ExternalController( IIdentityServerInteractionService interaction, IClientStore clientStore, IEventService events, ILogger <ExternalController> logger, IdentityUserStore users = null) { // if the TestUserStore is not in DI, then we'll just use the global users collection // this is where you would plug in your own custom identity management library (e.g. ASP.NET Identity) _users = users; _interaction = interaction; _clientStore = clientStore; _logger = logger; _events = events; }
public AccountAppService( ISmsSender smsSender, IdentityUserManager userManager, IdentityUserStore userStore, IIdentityUserRepository userRepository, IDistributedCache <AccountRegisterVerifyCacheItem> cache, PhoneNumberTokenProvider <IdentityUser> phoneNumberTokenProvider) { Cache = cache; SmsSender = smsSender; UserStore = userStore; UserManager = userManager; UserRepository = userRepository; PhoneNumberTokenProvider = phoneNumberTokenProvider; LocalizationResource = typeof(Localization.AccountResource); }
public AccountController( IIdentityServerInteractionService interaction, IClientStore clientStore, IAuthenticationSchemeProvider schemeProvider, IEventService events, IdentityUserStore users = null, IdentityUserDbContext identityUserDbContext = null) { // if the TestUserStore is not in DI, then we'll just use the global users collection // this is where you would plug in your own custom identity management library (e.g. ASP.NET Identity) _users = users; _interaction = interaction; _clientStore = clientStore; _schemeProvider = schemeProvider; _events = events; _identityUserDbContext = identityUserDbContext; }
public AccountAppService( ITotpService totpService, IdentityUserStore userStore, IdentityUserManager userManager, IWeChatOpenIdFinder weChatOpenIdFinder, IIdentityUserRepository userRepository, IUserSecurityCodeSender securityCodeSender, IDistributedCache <SmsSecurityTokenCacheItem> securityTokenCache) { TotpService = totpService; UserStore = userStore; UserManager = userManager; UserRepository = userRepository; WeChatOpenIdFinder = weChatOpenIdFinder; SecurityCodeSender = securityCodeSender; SecurityTokenCache = securityTokenCache; LocalizationResource = typeof(AccountResource); }
public AccountAppService( ITotpService totpService, IdentityUserStore userStore, IdentityUserManager userManager, IWeChatOpenIdFinder weChatOpenIdFinder, IIdentityUserRepository userRepository, IUserSecurityCodeSender securityCodeSender, IDistributedCache <SmsSecurityTokenCacheItem> securityTokenCache, AbpWeChatMiniProgramOptionsFactory miniProgramOptionsFactory, IOptions <IdentityOptions> identityOptions) { TotpService = totpService; UserStore = userStore; UserManager = userManager; UserRepository = userRepository; WeChatOpenIdFinder = weChatOpenIdFinder; SecurityCodeSender = securityCodeSender; SecurityTokenCache = securityTokenCache; MiniProgramOptionsFactory = miniProgramOptionsFactory; IdentityOptions = identityOptions; LocalizationResource = typeof(AccountResource); }
public ConcurrencyIdentityUserManager( IdentityUserStore store, IIdentityRoleRepository roleRepository, IIdentityUserRepository userRepository, IOptions <IdentityOptions> optionsAccessor, IPasswordHasher <IdentityUser> passwordHasher, IEnumerable <IUserValidator <IdentityUser> > userValidators, IEnumerable <IPasswordValidator <IdentityUser> > passwordValidators, ILookupNormalizer keyNormalizer, IdentityErrorDescriber errors, IServiceProvider services, ILogger <ConcurrencyIdentityUserManager> logger, ISettingProvider settingProvider, ICancellationTokenProvider cancellationTokenProvider, IOrganizationUnitRepository organizationUnitRepository, IMyUserRepository myUserRepository, IUnitOfWorkManager unitOfWorkManager) : base( store, roleRepository, userRepository, optionsAccessor, passwordHasher, userValidators, passwordValidators, keyNormalizer, errors, services, logger, cancellationTokenProvider, organizationUnitRepository, userRepository, settingProvider) { _myUserRepository = myUserRepository; _unitOfWorkManager = unitOfWorkManager; }
public UserIdentityManager() { identityUserStore = new IdentityUserStore <ApplicationUser>(new IdentityTestingContext()); identityUserManager = new UserManager <ApplicationUser>(identityUserStore); }
public ApplicationUserManager(IdentityUserStore store) : base(store) { }
public async Task GetAsync_by_page_request_should_find_users() { using var documentStore = new RavenDbTestDriverWrapper().GetDocumentStore(); var services = new ServiceCollection() .AddLogging(); services.AddIdentity <IdentityUser, IdentityRole>() .AddRavenDbStores(p => documentStore); IServiceProvider provider = services.AddIdentityServer4AdminRavenDbkStores <IdentityUser, IdentityRole>(p => documentStore).BuildServiceProvider(); using var scope = provider.CreateScope(); provider = scope.ServiceProvider; var userManager = provider.GetRequiredService <UserManager <IdentityUser> >(); var user = new IdentityUser { Id = Guid.NewGuid().ToString(), Email = "*****@*****.**", EmailConfirmed = true, UserName = Guid.NewGuid().ToString() }; var userResult = await userManager.CreateAsync(user); Assert.True(userResult.Succeeded); user = new IdentityUser { Id = Guid.NewGuid().ToString(), Email = "*****@*****.**", EmailConfirmed = true, UserName = Guid.NewGuid().ToString() }; userResult = await userManager.CreateAsync(user); Assert.True(userResult.Succeeded); user = new IdentityUser { Id = Guid.NewGuid().ToString(), Email = "*****@*****.**", EmailConfirmed = true, UserName = Guid.NewGuid().ToString() }; userResult = await userManager.CreateAsync(user); Assert.True(userResult.Succeeded); var sut = new IdentityUserStore <IdentityUser>(userManager, new ScopedAsynDocumentcSession(documentStore.OpenAsyncSession()), provider.GetRequiredService <ILogger <IdentityUserStore <IdentityUser> > >()); var result = await sut.GetAsync(new PageRequest { Filter = "contains(Email, '@exemple.com')", Take = 1 }); Assert.NotNull(result); Assert.Equal(3, result.Count); Assert.Single(result.Items); }
public ApplicationUserManager(IdentityUserStore <ApplicationUser> store) : base(store) { Initialize(); }
public ApplicationAccountManager( IdentityUserStore <ApplicationUser> userStore, ApplicationUserManager userManager, IdentityRoleStore roleStore, IdentityRoleManager roleManager) : base(userStore, userManager, roleStore, roleManager) { }