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