/*private readonly ILogger logger;*/
public AuthenticationProvider(IReferencedDataManager referencedDataManager, /*ILogger logger, */IPasswordHasher passwordHasher, IAuthenticationTokenCryptography authenticationTokenCryptography)
{
this.referencedDataManager = referencedDataManager;
/*this.logger = logger;*/
this.passwordHasher = passwordHasher;
this.authenticationTokenCryptography = authenticationTokenCryptography;
}
public UsersManager(IUsersRepository repository, IPasswordHasher hasher)
{
if (repository == null) throw new ArgumentNullException("repository");
if (hasher == null) throw new ArgumentNullException("hasher");
_repository = repository;
_hasher = hasher;
}
public UserManager(IUserRepository userRepository, ILandlordRepository landlordRepository, ITenantRepository tenantRepository, IPasswordHasher passwordHasher)
{
_userRepository = userRepository;
_passwordHasher = passwordHasher;
_landlordRepository = landlordRepository;
_tenantRepository = tenantRepository;
}
public void OneTimeSetup()
{
_passwordHasher = Substitute.For<IPasswordHasher>();
_passwordHasher.ComputeHash("somestring", new byte[4]).ReturnsForAnyArgs("hashedPassword");
_authService = new AuthenticationService(Session, _passwordHasher);
}
public AuthModule(IUserRepository userRepository, ITokenizer tokenizer, IPasswordHasher passwordHasher)
: base("smack/auth")
{
_userRepository = userRepository;
_tokenizer = tokenizer;
_passwordHasher = passwordHasher;
Post["/login"] = x => Login();
}
public AuthenticationService(Models.Repositories.IAccountRepository repository, IPasswordHasher hasher)
{
if (repository == null)
throw new ArgumentNullException("Repository is null!");
if (hasher == null)
throw new ArgumentNullException("Hasher is null");
this.repository = repository;
this.passwordHasher = hasher;
}
public AdminController(IAccountService accountService, IPasswordHasher hasher)
{
if (accountService == null)
throw new ArgumentNullException("accountService");
if (hasher == null)
throw new ArgumentNullException("hasher");
this.accountService = accountService;
this.hasher = hasher;
}
public AuthenticationManager(IAuthenticationsRepository authentiations, IUsersRepository users, IPasswordHasher hasher, int timeoutMinutes)
{
if (authentiations == null) throw new ArgumentNullException("authentiations");
if (users == null) throw new ArgumentNullException("users");
if (hasher == null) throw new ArgumentNullException("hasher");
_authentications = authentiations;
_users = users;
_hasher = hasher;
_timeoutMinutes = timeoutMinutes;
}
public SignInManager(
IAuthSettingsResolver settingsResolver,
IUserLookupProvider userLookupProvider,
IPasswordHasher<SimpleAuthUser> passwordHasher,
ILogger<SignInManager> logger)
{
authSettings = settingsResolver.GetCurrentAuthSettings();
userRepo = userLookupProvider;
this.passwordHasher = passwordHasher;
log = logger;
}
internal Password(IPasswordHasher passwordHasher, string password)
{
if (passwordHasher == null)
{
throw new ArgumentNullException("passwordHasher");
}
if (password == null)
{
throw new ArgumentNullException("password");
}
this.passwordHasher = passwordHasher;
Value = password;
}
public LoginModuleSettings(
LoginModuleOptions options = LoginModuleOptions.Default,
string encryptionChannelName = null, //uses default encryption channel if name is null
TimeSpan? passwordExpirationPeriod = null,
RecaptchaSettings recaptcha = null,
IPasswordHasher passwordHasher = null,
int bcryptWorkFactor = 10)
{
Options = options;
EncryptionChannelName = encryptionChannelName;
PasswordExpirationPeriod = passwordExpirationPeriod;
Recaptcha = recaptcha;
PasswordHasher = passwordHasher ?? new BCryptPasswordHasher(bcryptWorkFactor);
}
public MembershipService(IUserService userService,
ITemplateEngine templateEngine,
IMessageDeliveryService mailService,
IWebConfiguration webConfiguration,
IPasswordHasher passwordHasher,
ILocaleProvider localeProvider,
ITimeZonesProvider timeZonesProvider,
IConnectionProvider connectionProvider)
{
_userService = userService;
_templateEngine = templateEngine;
_mailService = mailService;
_webConfiguration = webConfiguration;
_passwordHasher = passwordHasher;
_localeProvider = localeProvider;
_timeZonesProvider = timeZonesProvider;
_connectionProvider = connectionProvider;
}
public AccountController(IUserLoginStore<User, Guid> userLoginStore, IUserPasswordStore<User, Guid> userPasswordStore, IPasswordHasher passwordHasher)
{
if (userLoginStore == null)
{
throw new ArgumentNullException("userLoginStore");
}
if (userPasswordStore == null)
{
throw new ArgumentNullException("userPasswordStore");
}
if (passwordHasher == null)
{
throw new ArgumentNullException("passwordHasher");
}
_userLoginStore = userLoginStore;
_userPasswordStore = userPasswordStore;
_passwordHasher = passwordHasher;
}
public UserIdentityApplicationService(
IClaimsIdentityFactory claimsIdentityFactory,
IPasswordHasher passwordHasher,
IIdentityValidator<string> passwordIdentityValidator,
IIdentityValidator<User> userIdentityValidator,
IUserRepository userRepository,
IDbContextScopeFactory dbContextScopeFactory,
IUserTokenProvider userTokenProvider,
IUserTokenTwoFactorProvider userTokenTwoFactorProvider,
IMapper mapper,
ILog logger)
: base(dbContextScopeFactory, mapper, logger)
{
this.claimsIdentityFactory = claimsIdentityFactory;
this.passwordHasher = passwordHasher;
this.passwordIdentityValidator = passwordIdentityValidator;
this.userIdentityValidator = userIdentityValidator;
this.userRepository = userRepository;
this.userTokenProvider = userTokenProvider;
this.userTokenTwoFactorProvider = userTokenTwoFactorProvider;
}
public OAuthProvider(string clientId, Func<IUserPasswordStore<User, Guid>> userPasswordStoreFactory, IPasswordHasher passwordHasher)
{
if (clientId == null)
{
throw new ArgumentNullException("clientId");
}
if (userPasswordStoreFactory == null)
{
throw new ArgumentNullException("userPasswordStoreFactory");
}
if (passwordHasher == null)
{
throw new ArgumentNullException("passwordHasher");
}
_clientId = clientId;
_userPasswordStoreFactory = userPasswordStoreFactory;
_passwordHasher = passwordHasher;
}
public UserManager(
RoleManager roleManager,
UserStore store,
IOptions <IdentityOptions> optionsAccessor,
IPasswordHasher <User> passwordHasher,
IEnumerable <IUserValidator <User> > userValidators,
IEnumerable <IPasswordValidator <User> > passwordValidators,
ILookupNormalizer keyNormalizer,
IdentityErrorDescriber errors,
IServiceProvider services,
ILogger <UserManager <User> > logger,
IPermissionManager permissionManager,
IUnitOfWorkManager unitOfWorkManager,
ICacheManager cacheManager,
IRepository <OrganizationUnit, long> organizationUnitRepository,
IRepository <UserOrganizationUnit, long> userOrganizationUnitRepository,
IOrganizationUnitSettings organizationUnitSettings,
ISettingManager settingManager)
: base(
roleManager,
store,
optionsAccessor,
passwordHasher,
userValidators,
passwordValidators,
keyNormalizer,
errors,
services,
logger,
permissionManager,
unitOfWorkManager,
cacheManager,
organizationUnitRepository,
userOrganizationUnitRepository,
organizationUnitSettings,
settingManager)
{
}
public UserManager(IUserStore <User> store,
IOptions <IdentityOptions> optionsAccessor,
IPasswordHasher <User> passwordHasher,
IEnumerable <IUserValidator <User> > userValidators,
IEnumerable <IPasswordValidator <User> > passwordValidators,
ICommonPasswordValidator commonPasswordValidator,
ILookupNormalizer keyNormalizer,
IdentityErrorDescriber errors,
IServiceProvider services,
ILogger <UserManager <User> > logger)
: base(
store,
optionsAccessor,
passwordHasher,
userValidators,
passwordValidators.Concat(new IPasswordValidator <User>[] { commonPasswordValidator }),
keyNormalizer,
errors,
services,
logger
)
{
}
public UserAppService(
IRepository <User, long> repository,
UserManager userManager,
RoleManager roleManager,
IRepository <Role> roleRepository,
IPasswordHasher <User> passwordHasher,
IAbpSession abpSession,
LogInManager logInManager,
IRepository <User, long> userRepository,
IObjectMapper objectMapper,
IDBHelper helper)
: base(repository)
{
_userManager = userManager;
_roleManager = roleManager;
_roleRepository = roleRepository;
_passwordHasher = passwordHasher;
_abpSession = abpSession;
_logInManager = logInManager;
_helper = helper;
_userRepository = userRepository;
_objectMapper = objectMapper;
}
public EmployeesManager(
IUserStore <UserModel> store,
IOptions <IdentityOptions> optionsAccessor,
IPasswordHasher <UserModel> passwordHasher,
IEnumerable <IUserValidator <UserModel> > userValidators,
IEnumerable <IPasswordValidator <UserModel> > passwordValidators,
ILookupNormalizer keyNormalizer,
IdentityErrorDescriber errors,
IServiceProvider services,
ILogger <UserManager <UserModel> > logger
) : base(
store,
optionsAccessor,
passwordHasher,
userValidators,
passwordValidators,
keyNormalizer,
errors,
services,
logger
)
{
}
public UserAppService(
IRepository <User, long> repository,
UserManager userManager,
RoleManager roleManager,
IRepository <OrganizationUnit, long> orgUnitRepository,
IRepository <Role> roleRepository,
IPasswordHasher <User> passwordHasher,
IAbpSession abpSession,
IUnitOfWorkManager unitOfWorkManager,
LogInManager logInManager,
SmsAuthManager smsAuthManager)
: base(repository)
{
_userManager = userManager;
_roleManager = roleManager;
_orgUnitRepository = orgUnitRepository;
_roleRepository = roleRepository;
_passwordHasher = passwordHasher;
_abpSession = abpSession;
_unitOfWorkManager = unitOfWorkManager;
_logInManager = logInManager;
_smsAuthManager = smsAuthManager;
}
public IdentityInitializerTests()
{
_store = Substitute.For <IUserStore <ApplicationUser> >();
_optionsAccessor = Substitute.For <IOptions <IdentityOptions> >();
_passwordHasher = Substitute.For <IPasswordHasher <ApplicationUser> >();
_userValidators = Substitute.For <IEnumerable <IUserValidator <ApplicationUser> > >();
_passwordValidators = Substitute.For <IEnumerable <IPasswordValidator <ApplicationUser> > >();
_keyNormalizer = Substitute.For <ILookupNormalizer>();
_errors = Substitute.For <IdentityErrorDescriber>();
_services = Substitute.For <IServiceProvider>();
_logger = Substitute.For <ILogger <UserManager <ApplicationUser> > >();
_userManager = Substitute.For <UserManager <ApplicationUser> >(_store,
_optionsAccessor,
_passwordHasher,
_userValidators,
_passwordValidators,
_keyNormalizer,
_errors,
_services,
_logger);
_droneRoleValidator = Substitute.For <IDroneRoleValidator>();
_validateDatabase = Substitute.For <IValidateDatabase>();
}
//private readonly IConnectionMultiplexer _redis;
public IdentityService(
IOptions <IdentityOption> options,
IHttpContextAccessor httpContextAccessor,
UserManager <User> userManager,
SignInManager <User> signInManager,
IPasswordHasher <User> passwordHasher,
ICoreUnitOfWork uow,
IEnumerable <IUserInfoService> userInfoServices,
IDistributedCache cache,
//IConnectionMultiplexer redis,
IWorkContext workContext)
{
_options = options.Value;
_httpContextAccessor = httpContextAccessor;
_userManager = userManager;
_signInManager = signInManager;
_passwordHasher = passwordHasher;
_uow = uow;
_userInfoServices = userInfoServices;
_cache = cache;
_workContext = workContext;
//_redis = redis;
}
public static async Task <AppUser> CreateAppUserAsync(PayrollDbContext dbContext
, Employee employee,
UserManager <AppUser> userManager,
IPasswordHasher <AppUser> passwordHasher)
{
AppUser user = new AppUser()
{
FirstName = employee.Name,
SecondName = employee.Surname,
Photo = employee.Photo,
Adress = employee.DistrictRegistration,
Birth = employee.BirthDay,
UserName = employee.Name,
Email = employee.Email,
};
user.PasswordHash = passwordHasher.HashPassword(user, "12345");
await userManager.CreateAsync(user);
await dbContext.SaveChangesAsync();
return(user);
}
public UserAppService(
IRepository <User, long> repository,
UserManager userManager,
RoleManager roleManager,
IRepository <Role> roleRepository,
IPasswordHasher <User> passwordHasher,
IAbpSession abpSession,
LogInManager logInManager,
ICacheManager cacheManager,
//IEmailSender emailSender,
IClientInfoProvider clientInfoProvider)
: base(repository)
{
_userManager = userManager;
_roleManager = roleManager;
_roleRepository = roleRepository;
_passwordHasher = passwordHasher;
_abpSession = abpSession;
_logInManager = logInManager;
_cacheManager = cacheManager;
//_emailSender = emailSender;
_clientInfoProvider = clientInfoProvider;
}
public ImportUsersToExcelJob(
RoleManager roleManager,
IUserListExcelDataReader userListExcelDataReader,
IInvalidUserExporter invalidUserExporter,
IUserPolicy userPolicy,
IEnumerable <IPasswordValidator <User> > passwordValidators,
IPasswordHasher <User> passwordHasher,
IAppNotifier appNotifier,
IBinaryObjectManager binaryObjectManager,
ILocalizationManager localizationManager,
IObjectMapper objectMapper)
{
_roleManager = roleManager;
_userListExcelDataReader = userListExcelDataReader;
_invalidUserExporter = invalidUserExporter;
_userPolicy = userPolicy;
_passwordValidators = passwordValidators;
_passwordHasher = passwordHasher;
_appNotifier = appNotifier;
_binaryObjectManager = binaryObjectManager;
_objectMapper = objectMapper;
_localizationSource = localizationManager.GetSource(SdiscoConsts.LocalizationSourceName);
}
public SendService(
ISendRepository sendRepository,
IUserRepository userRepository,
IUserService userService,
IOrganizationRepository organizationRepository,
ISendFileStorageService sendFileStorageService,
IPasswordHasher <User> passwordHasher,
IPushNotificationService pushService,
GlobalSettings globalSettings,
IPolicyRepository policyRepository,
ICurrentContext currentContext)
{
_sendRepository = sendRepository;
_userRepository = userRepository;
_userService = userService;
_policyRepository = policyRepository;
_organizationRepository = organizationRepository;
_sendFileStorageService = sendFileStorageService;
_passwordHasher = passwordHasher;
_pushService = pushService;
_globalSettings = globalSettings;
_currentContext = currentContext;
}
public ImportUsersToExcelJob(
RoleManager roleManager,
IUserListExcelDataReader userListExcelDataReader,
IInvalidUserExporter invalidUserExporter,
IUserPolicy userPolicy,
IEnumerable <IPasswordValidator <User> > passwordValidators,
IPasswordHasher <User> passwordHasher,
IAppNotifier appNotifier,
IBinaryObjectManager binaryObjectManager,
IObjectMapper objectMapper,
IUnitOfWorkManager unitOfWorkManager)
{
_roleManager = roleManager;
_userListExcelDataReader = userListExcelDataReader;
_invalidUserExporter = invalidUserExporter;
_userPolicy = userPolicy;
_passwordValidators = passwordValidators;
_passwordHasher = passwordHasher;
_appNotifier = appNotifier;
_binaryObjectManager = binaryObjectManager;
_objectMapper = objectMapper;
_unitOfWorkManager = unitOfWorkManager;
}
public UserManager(
IUserStore <User> store,
AppDbContext db,
IOptions <IdentityOptions> optionsAccessor,
IPasswordHasher <User> passwordHasher,
IEnumerable <IUserValidator <User> > userValidators,
IEnumerable <IPasswordValidator <User> > passwordValidators,
ILookupNormalizer keyNormalizer,
IdentityErrorDescriber errors,
IServiceProvider services,
ILogger <UserManager> logger)
: base(store,
optionsAccessor,
passwordHasher,
userValidators,
passwordValidators,
keyNormalizer,
errors,
services,
logger)
{
_dbContext = db;
}
public IdentityUserManager(
IdentityUserStore store,
IOptions <IdentityOptions> optionsAccessor,
IPasswordHasher <IdentityUser> passwordHasher,
IEnumerable <IUserValidator <IdentityUser> > userValidators,
IEnumerable <IPasswordValidator <IdentityUser> > passwordValidators,
ILookupNormalizer keyNormalizer, IdentityErrorDescriber errors,
IServiceProvider services,
ILogger <IdentityUserManager> logger,
ICancellationTokenProvider cancellationTokenProvider)
: base(
store,
optionsAccessor,
passwordHasher,
userValidators,
passwordValidators,
keyNormalizer,
errors,
services,
logger)
{
_cancellationTokenProvider = cancellationTokenProvider;
}
public UserManager(IUserStore store,
IOptions <IdentityOptions> optionsAccessor,
IPasswordHasher <User> passwordHasher,
IEnumerable <IUserValidator <User> > userValidators,
IEnumerable <IPasswordValidator <User> > passwordValidators,
ILookupNormalizer keyNormalizer,
IdentityErrorDescriber errors,
IServiceProvider services,
ILogger <UserManager <User> > logger,
ISignal signal)
: base(store,
optionsAccessor,
passwordHasher,
userValidators,
passwordValidators,
keyNormalizer,
errors,
services,
logger)
{
_userStore = store;
_signal = signal;
}
public CognitoUserManager(IUserStore <TUser> store,
IOptions <IdentityOptions> optionsAccessor,
IPasswordHasher <TUser> passwordHasher,
IEnumerable <IUserValidator <TUser> > userValidators,
IEnumerable <IPasswordValidator <TUser> > passwordValidators,
CognitoKeyNormalizer keyNormalizer,
IdentityErrorDescriber errors,
IServiceProvider services,
ILogger <UserManager <TUser> > logger,
IHttpContextAccessor httpContextAccessor) : base(store, optionsAccessor, passwordHasher, userValidators, passwordValidators, keyNormalizer, errors, services, logger)
{
var userStore = store as CognitoUserStore <TUser>;
if (userStore == null)
{
throw new ArgumentException("The store must be of type CognitoUserStore<TUser>", nameof(store));
}
else
{
_userStore = userStore;
}
_httpContextAccessor = httpContextAccessor ?? throw new ArgumentException(nameof(httpContextAccessor));
}
private void CreateDefaultSuperUser(ApplicationDbContext context, IPasswordHasher <ApplicationUser> passwordHasher)
{
var defaultSuperUsername = "******";
var defaultSuperUserId = "2caea85c-33d1-43c3-84f7-68e946a09e11";
if (context.Users.FirstOrDefault(u => u.UserName == defaultSuperUsername) == null)
{
var defaultSuperUser = new ApplicationUser
{
Id = defaultSuperUserId,
UserName = defaultSuperUsername,
Email = "",
NormalizedEmail = defaultSuperUsername.ToUpper(),
PhoneNumber = "",
SecurityStamp = Guid.NewGuid().ToString(),
NormalizedUserName = defaultSuperUsername.ToUpper(),
IsActive = true
};
var hashedPassword = passwordHasher.HashPassword(defaultSuperUser, "Password");
defaultSuperUser.PasswordHash = hashedPassword;
context.Users.Add(defaultSuperUser);
var superAdminOfficerRoleId = Convert.ToInt16(Roles.ADMIN_SUPERVISOR).ToString();
var defaultSuperAdminRoleAssigned = context.UserRoles.FirstOrDefault(ur => ur.RoleId == superAdminOfficerRoleId && ur.UserId == defaultSuperUserId) != null;
if (!defaultSuperAdminRoleAssigned)
{
context.UserRoles.Add(new IdentityUserRole <string>
{
RoleId = superAdminOfficerRoleId,
UserId = defaultSuperUserId
});
}
}
}
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 TenantManager(
IRepository <Tenant> tenantRepository,
IRepository <TenantFeatureSetting, long> tenantFeatureRepository,
EditionManager editionManager,
IUnitOfWorkManager unitOfWorkManager,
RoleManager roleManager,
//IUserEmailer userEmailer,
//TenantDemoDataBuilder demoDataBuilder,
UserManager userManager,
INotificationSubscriptionManager notificationSubscriptionManager,
//IAppNotifier appNotifier,
IAbpZeroFeatureValueStore featureValueStore,
IAbpZeroDbMigrator abpZeroDbMigrator,
IPasswordHasher <User> passwordHasher,
IRepository <SubscribableEdition> subscribableEditionRepository) : base(
tenantRepository,
tenantFeatureRepository,
editionManager,
featureValueStore
)
{
AbpSession = NullAbpSession.Instance;
_unitOfWorkManager = unitOfWorkManager;
_roleManager = roleManager;
//_userEmailer = userEmailer;
//_demoDataBuilder = demoDataBuilder;
_userManager = userManager;
_notificationSubscriptionManager = notificationSubscriptionManager;
//_appNotifier = appNotifier;
_abpZeroDbMigrator = abpZeroDbMigrator;
_passwordHasher = passwordHasher;
_subscribableEditionRepository = subscribableEditionRepository;
}
public LdapUserManager(
ILdapService ldapService,
IUserStore <LdapUser> store,
IOptions <IdentityOptions> optionsAccessor,
IPasswordHasher <LdapUser> passwordHasher,
IEnumerable <IUserValidator <LdapUser> > userValidators,
IEnumerable <IPasswordValidator <LdapUser> > passwordValidators,
ILookupNormalizer keyNormalizer,
IdentityErrorDescriber errors,
IServiceProvider services,
ILogger <LdapUserManager> logger)
: base(
store,
optionsAccessor,
passwordHasher,
userValidators,
passwordValidators,
keyNormalizer,
errors,
services,
logger)
{
this._ldapService = ldapService;
}
public AppUserManager(
IDbContext _context,
ErrorDescriber _errors,
ILookupNormalizer _keyNormalizer,
ILogger <AppUserManager> _logger,
IOptions <IdentityOptions> _options,
IPasswordHasher <User> _passwordHasher,
IEnumerable <IPasswordValidator <User> > _passwordValidators,
IServiceProvider services,
IUserStore <User> _userStore,
IEnumerable <IUserValidator <User> > _userValidators
) : base(_userStore, _options, _passwordHasher, _userValidators, _passwordValidators, _keyNormalizer, _errors, services, _logger)
{
errors = _errors;
keyNormalizer = _keyNormalizer;
logger = _logger;
options = _options;
passwordHasher = _passwordHasher;
passwordValidators = _passwordValidators;
serviceProvider = services;
userStore = _userStore;
userValidators = _userValidators;
context = _context;
}
public UserService(
IUserRepository userRepository,
ICipherRepository cipherRepository,
IMailService mailService,
IPushService pushService,
IUserStore <User> store,
IOptions <IdentityOptions> optionsAccessor,
IPasswordHasher <User> passwordHasher,
IEnumerable <IUserValidator <User> > userValidators,
IEnumerable <IPasswordValidator <User> > passwordValidators,
ILookupNormalizer keyNormalizer,
IdentityErrorDescriber errors,
IServiceProvider services,
ILogger <UserManager <User> > logger,
CurrentContext currentContext)
: base(
store,
optionsAccessor,
passwordHasher,
userValidators,
passwordValidators,
keyNormalizer,
errors,
services,
logger)
{
_userRepository = userRepository;
_cipherRepository = cipherRepository;
_mailService = mailService;
_pushService = pushService;
_identityOptions = optionsAccessor?.Value ?? new IdentityOptions();
_identityErrorDescriber = errors;
_passwordHasher = passwordHasher;
_passwordValidators = passwordValidators;
_currentContext = currentContext;
}
public ApplicationUserManager(ApplicationDbContext context, IUserStore <ApplicationUser> store, IOptions <IdentityOptions> optionsAccessor, IPasswordHasher <ApplicationUser> passwordHasher, IEnumerable <IUserValidator <ApplicationUser> > userValidators, IEnumerable <IPasswordValidator <ApplicationUser> > passwordValidators, ILookupNormalizer keyNormalizer, IdentityErrorDescriber errors, IServiceProvider services, ILogger <UserManager <ApplicationUser> > logger) : base(store, optionsAccessor, passwordHasher, userValidators, passwordValidators, keyNormalizer, errors, services, logger)
{
this.context = context;
}
public InMemoryRepository(IPasswordHasher passwordHasher)
{
PasswordService = passwordHasher;
}
public UserManager(Func<IDbConnection> connectionFactory, IPasswordHasher hasher = null)
: this(new FunctionBasedConnectionFactory(connectionFactory), hasher)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="UserManager"/> class with
/// a database provider invariant name, a connection string and a password hasher.
/// </summary>
/// <param name="providerName">Invariant name of a provider. Used to get a used to get <see cref="DbProviderFactory"/>.</param>
/// <param name="connectionString">Connection string to connect to the database.</param>
/// <param name="hasher">Password hashing strategy.</param>
public UserManager(string providerName, string connectionString, IPasswordHasher hasher = null)
: this(new DbProviderBasedConnectionFactory(providerName, connectionString), hasher)
{
}
/// <summary>
/// Used to configure how passwords are being hashed and which messages should be used when transfering authentication
/// information
/// over the network.
/// </summary>
/// <param name="hasher">Password hasher, the dault one is <see cref="PasswordHasherRfc2898" />.</param>
/// <param name="messageFactory">Message factory, the default on is <see cref="AuthenticationMessageFactory" />.</param>
public void ConfigureAuthentication(IPasswordHasher hasher, IAuthenticationMessageFactory messageFactory)
{
if (hasher == null) throw new ArgumentNullException("hasher");
if (messageFactory == null) throw new ArgumentNullException("messageFactory");
_authenticationMessageFactory = messageFactory;
_passwordHasher = hasher;
}
public AutoShoppingDbContext(IPasswordHasher <IdentityUser> passwordHasher)
{
_passwordHasher = passwordHasher;
}
public UserController(IPasswordHasher passwordHasher, UserContext context)
{
_passwordHasher = passwordHasher;
_userDb = context;
}
public AuthenticationService(IDocumentSession session, IPasswordHasher passwordHasher)
{
_passwordHasher = passwordHasher;
_session = session;
}
public AuthenticationMessageFactory(IPasswordHasher hasher)
{
if (hasher == null) throw new ArgumentNullException("hasher");
Hasher = hasher;
}
public UserManager([NotNull] IReferencedDataManager referencedDataManager, [NotNull] IPasswordHasher passwordHasher, [NotNull] IEmailSender emailSender)
{
this.referencedDataManager = referencedDataManager;
this.passwordHasher = passwordHasher;
this.emailSender = emailSender;
}
/// <summary>
/// Create a new EntityFrameworkRepository with a connection string.
/// </summary>
/// <param name="connectionString">Connection string to use to initialize the Entity Framework context.</param>
public EntityFrameworkRepository(IDbContext context, IPasswordHasher passwordHasher)
{
DBContext = context;
PasswordService = passwordHasher;
}
public AccountService(IUserRepository <User> userRepository, IJwtGenerator jwtGenerator, IPasswordHasher <User> passwordHasher)
{
_userRepository = userRepository;
_jwtGenerator = jwtGenerator;
_passwordHasher = passwordHasher;
}
public UsersService(MissioContext missioContext, IPasswordHasher <User> passwordService, IWebClientService webClientService)
{
_webClientService = webClientService;
_passwordService = passwordService;
_missioContext = missioContext;
}
public UserAccount(IPasswordHasher passwordHasher)
{
_passwordHasher = passwordHasher;
}
public LoginService(IUserRepository userRepository, IPasswordHasher passwordHasher)
{
this._userRepository = userRepository;
this._passwordHasher = passwordHasher;
}
public UserManager(IConnectionFactory connectionFactory, IPasswordHasher hasher = null)
{
this.Connection = connectionFactory;
this.PasswordHasher = hasher ?? new PasswordHasher();
this.MinPasswordLength = DefaultMinPasswordLength;
}
public LoginController(ITokenGenerator _tokenGenerator, IPasswordHasher _passwordHasher, IUserDAO _userDAO)
{
tokenGenerator = _tokenGenerator;
passwordHasher = _passwordHasher;
userDAO = _userDAO;
}
public AdminAccountRepository(IDatabaseRetriever databaseRetriever,
IPasswordHasher passwordHasher)
{
this.databaseRetriever = databaseRetriever;
this.passwordHasher = passwordHasher;
}
public UlearnUserManager(IUserStore <ApplicationUser> store, IOptions <IdentityOptions> optionsAccessor, IPasswordHasher <ApplicationUser> passwordHasher, IEnumerable <IUserValidator <ApplicationUser> > userValidators, IEnumerable <IPasswordValidator <ApplicationUser> > passwordValidators, ILookupNormalizer keyNormalizer, IdentityErrorDescriber errors, IServiceProvider services, ILogger <UserManager <ApplicationUser> > log)
: base(store, optionsAccessor, passwordHasher, userValidators, passwordValidators, keyNormalizer, errors, services, log)
{
Options.User.AllowedUserNameCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
}
public AdminAccountEditFormStore(IDatabaseRetriever databaseRetriever, IPasswordHasher passwordHasher)
{
this.databaseRetriever = databaseRetriever;
this.passwordHasher = passwordHasher;
}
