public AppUserManager(IUserStore <User, int> store) : base(store)
{
UserValidator = new UserValidator <User, int>(this)
{
RequireUniqueEmail = true,
AllowOnlyAlphanumericUserNames = false
};
PasswordValidator = new PasswordValidator
{
RequiredLength = 8,
RequireDigit = true,
RequireNonLetterOrDigit = true,
RequireLowercase = true,
RequireUppercase = true,
};
UserTokenProvider = new EmailTokenProvider <User, int>()
{
Subject = "Subject",
BodyFormat = "Body"
};
EmailService = IoContainer.Resolve <IIdentityMessageService>();
}
public UserService(RoleManager <RoleModel> roleManager, ApplicationUserManager userManager, ILogger <UserService> logger, SignInManager <UserModel> signInManager, IMonitoringService telemetryClient)
{
_userManager = userManager;
_logger = logger;
_signInManager = signInManager;
_telemetryClient = telemetryClient;
var emailTokenProvider = new EmailTokenProvider <UserModel>();
_userManager.RegisterTokenProvider("Default", emailTokenProvider);
if (!roleManager.RoleExistsAsync("Player").Result)
{
roleManager.CreateAsync(new RoleModel {
Name = "Player"
}).Wait();
}
if (!roleManager.RoleExistsAsync("Administrator").Result)
{
roleManager.CreateAsync(new RoleModel {
Name = "Administrator"
}).Wait();
}
}
public ApplicationUserManagerService(IUserStore <ApplicationUser, int> store,
IIdentityMessageService emailService,
IDataProtectionProvider dataProtectionProvider)
: base(store)
{
UserTokenProvider = new EmailTokenProvider <ApplicationUser, int>();
EmailService = emailService;
Configure(dataProtectionProvider);
}
private void RegisterEmailProvider()
{
var provider = new EmailTokenProvider <ApplicationUser>
{
Subject = "Security Code",
BodyFormat = "Your security code is {0}",
};
this.RegisterTwoFactorProvider("Email Code", provider);
}
public UserService(ApplicationUserManager userManager, ILogger <UserService> logger, SignInManager <UserModel> signInManager)
{
_userManager = userManager;
_logger = logger;
_signInManager = signInManager;
var emailTokenProvider = new EmailTokenProvider <UserModel>();
_userManager.RegisterTokenProvider("Default", emailTokenProvider);
}
public static ApplicationUserManager Create(
IdentityFactoryOptions <ApplicationUserManager> options,
IOwinContext context)
{
ApplicationUserManager applicationUserManager1 = new ApplicationUserManager((IUserStore <ApplicationUser>) new UserStore <ApplicationUser>((DbContext)OwinContextExtensions.Get <ApplicationDbContext>(context)));
ApplicationUserManager applicationUserManager2 = applicationUserManager1;
UserValidator <ApplicationUser> userValidator1 = new UserValidator <ApplicationUser>((UserManager <ApplicationUser, string>)applicationUserManager1);
((UserValidator <ApplicationUser, string>)userValidator1).set_AllowOnlyAlphanumericUserNames(false);
((UserValidator <ApplicationUser, string>)userValidator1).set_RequireUniqueEmail(true);
UserValidator <ApplicationUser> userValidator2 = userValidator1;
((UserManager <ApplicationUser, string>)applicationUserManager2).set_UserValidator((IIdentityValidator <ApplicationUser>)userValidator2);
ApplicationUserManager applicationUserManager3 = applicationUserManager1;
PasswordValidator passwordValidator1 = new PasswordValidator();
passwordValidator1.set_RequiredLength(6);
passwordValidator1.set_RequireNonLetterOrDigit(true);
passwordValidator1.set_RequireDigit(true);
passwordValidator1.set_RequireLowercase(true);
passwordValidator1.set_RequireUppercase(true);
PasswordValidator passwordValidator2 = passwordValidator1;
((UserManager <ApplicationUser, string>)applicationUserManager3).set_PasswordValidator((IIdentityValidator <string>)passwordValidator2);
((UserManager <ApplicationUser, string>)applicationUserManager1).set_UserLockoutEnabledByDefault(true);
((UserManager <ApplicationUser, string>)applicationUserManager1).set_DefaultAccountLockoutTimeSpan(TimeSpan.FromMinutes(5.0));
((UserManager <ApplicationUser, string>)applicationUserManager1).set_MaxFailedAccessAttemptsBeforeLockout(5);
ApplicationUserManager applicationUserManager4 = applicationUserManager1;
PhoneNumberTokenProvider <ApplicationUser> numberTokenProvider1 = new PhoneNumberTokenProvider <ApplicationUser>();
((PhoneNumberTokenProvider <ApplicationUser, string>)numberTokenProvider1).set_MessageFormat("Your security code is {0}");
PhoneNumberTokenProvider <ApplicationUser> numberTokenProvider2 = numberTokenProvider1;
((UserManager <ApplicationUser, string>)applicationUserManager4).RegisterTwoFactorProvider("Phone Code", (IUserTokenProvider <ApplicationUser, string>)numberTokenProvider2);
ApplicationUserManager applicationUserManager5 = applicationUserManager1;
EmailTokenProvider <ApplicationUser> emailTokenProvider1 = new EmailTokenProvider <ApplicationUser>();
((EmailTokenProvider <ApplicationUser, string>)emailTokenProvider1).set_Subject("Security Code");
((EmailTokenProvider <ApplicationUser, string>)emailTokenProvider1).set_BodyFormat("Your security code is {0}");
EmailTokenProvider <ApplicationUser> emailTokenProvider2 = emailTokenProvider1;
((UserManager <ApplicationUser, string>)applicationUserManager5).RegisterTwoFactorProvider("Email Code", (IUserTokenProvider <ApplicationUser, string>)emailTokenProvider2);
((UserManager <ApplicationUser, string>)applicationUserManager1).set_EmailService((IIdentityMessageService) new EmailService());
((UserManager <ApplicationUser, string>)applicationUserManager1).set_SmsService((IIdentityMessageService) new SmsService());
IDataProtectionProvider protectionProvider = options.get_DataProtectionProvider();
if (protectionProvider != null)
{
((UserManager <ApplicationUser, string>)applicationUserManager1).set_UserTokenProvider((IUserTokenProvider <ApplicationUser, string>) new DataProtectorTokenProvider <ApplicationUser>(protectionProvider.Create(new string[1]
{
"ASP.NET Identity"
})));
}
return(applicationUserManager1);
}
public ApplicationUserManager(IUserStore <ApplicationUser> store) : base(store)
{
//TODO: update password validation rules
PasswordValidator = new MinimumLengthValidator(4);
UserLockoutEnabledByDefault = true;
DefaultAccountLockoutTimeSpan = TimeSpan.FromMinutes(3);
MaxFailedAccessAttemptsBeforeLockout = 5;
//TODO: change provider to specificated one
UserTokenProvider = new EmailTokenProvider <ApplicationUser>();
}
public async Task EmailConfirmationToken()
{
var tokenProvider = new EmailTokenProvider <ApplicationUser>();
this._userManager.RegisterTokenProvider("Default", tokenProvider);
await this._userManager.CreateAsync(new ApplicationUser { UserName = "******", Email = "*****@*****.**", EmailConfirmed = false }, "Welcome");
var x = await this._userManager.FindByEmailAsync("*****@*****.**");
var token = await this._userManager.GeneratePasswordResetTokenAsync(x);
await this._userManager.ResetPasswordAsync(x, token, "Welcome!");
}
/// <summary>
/// Configure user manager.
/// </summary>
/// <typeparam name="TUser">Type of the user.</typeparam>
/// <param name="manager">User manager which has to be configured.</param>
/// <param name="emailDisplayName">Display name for the email service.</param>
public static void ConfigureUserManager <TUser>(this UserManager <TUser> manager, string emailDisplayName)
where TUser : DubUser
{
if (manager == null)
{
throw new ArgumentNullException("manager");
}
if (string.IsNullOrWhiteSpace(emailDisplayName))
{
throw new ArgumentException("Email display name could not be empty.", "emailDisplayName");
}
manager.UserValidator = new UserValidator <TUser>(manager)
{
AllowOnlyAlphanumericUserNames = false,
RequireUniqueEmail = true
};
// Configure validation logic for passwords
manager.PasswordValidator = new PasswordValidator
{
RequiredLength = 6,
RequireNonLetterOrDigit = true,
RequireDigit = true,
RequireLowercase = true,
RequireUppercase = true,
};
// Configure user lockout defaults
manager.UserLockoutEnabledByDefault = true;
manager.DefaultAccountLockoutTimeSpan = TimeSpan.FromMinutes(5);
manager.MaxFailedAccessAttemptsBeforeLockout = 5;
// Register two factor authentication providers. This application uses Phone and Emails as a step of receiving a code for verifying the user
// You can write your own provider and plug it in here.
var phoneProvider = new PhoneNumberTokenProvider <TUser>
{
MessageFormat = "Your security code is {0}"
};
var emailProvider = new EmailTokenProvider <TUser>
{
Subject = "Security Code",
BodyFormat = "Your security code is {0}"
};
manager.RegisterTwoFactorProvider("Phone Code", phoneProvider);
manager.RegisterTwoFactorProvider("Email Code", emailProvider);
manager.EmailService = new MarkdownEmailService(emailDisplayName);
manager.SmsService = new EmptySmsService();
}
public ApplicationUserManager(IUserStore <LoginUser, int> store, EmailService emailService, SmsService smsService, IdentityFactoryOptions <ApplicationUserManager> options) : base(store)
{
// Configure validation logic for usernames
this.UserValidator = new UserValidator <LoginUser, int>(this)
{
AllowOnlyAlphanumericUserNames = false,
RequireUniqueEmail = true
};
// Configure validation logic for passwords
PasswordValidator = new PasswordValidator
{
RequiredLength = 6,
RequireNonLetterOrDigit = false,
RequireDigit = false,
RequireLowercase = false,
RequireUppercase = false,
};
// Configure user lockout defaults
UserLockoutEnabledByDefault = true;
DefaultAccountLockoutTimeSpan = TimeSpan.FromMinutes(5);
MaxFailedAccessAttemptsBeforeLockout = 5;
// Register two factor authentication providers. This application uses Phone and Emails as a step of receiving a code for verifying the user
// You can write your own provider and plug it in here.
RegisterTwoFactorProvider("Phone Code", new PhoneNumberTokenProvider <LoginUser, int>
{
MessageFormat = "Your security code is {0}"
});
RegisterTwoFactorProvider("Email Code", new EmailTokenProvider <LoginUser, int>
{
Subject = "Security Code",
BodyFormat = "Your security code is {0}"
});
EmailService = emailService;
SmsService = smsService;
var dataProtectionProvider = options.DataProtectionProvider;
if (dataProtectionProvider != null)
{
IDataProtector dataProtector = dataProtectionProvider.Create("ASP.NET Identity");
UserTokenProvider = new DataProtectorTokenProvider <LoginUser, int>(dataProtector);
}
//alternatively use this if you are running in Azure Web Sites
UserTokenProvider = new EmailTokenProvider <LoginUser, int>();
}
public AccountController(UserManager <IdentityUser> userManager,
SignInManager <IdentityUser> signInManager,
StoreContext context,
IEmailSender emailSender)
{
_userManager = userManager;
var provider = new EmailTokenProvider <IdentityUser>();
_userManager.RegisterTokenProvider("Default", provider);
_signInManager = signInManager;
_emailSender = emailSender;
_context = context;
}
private void Config()
{
// Configure validation logic for usernames
UserValidator = new UserValidator <User>(this)
{
AllowOnlyAlphanumericUserNames = false,
RequireUniqueEmail = true
};
// Configure validation logic for passwords
PasswordValidator = new PasswordValidator
{
RequiredLength = 6,
//RequireNonLetterOrDigit = true,
//RequireDigit = true,
//RequireLowercase = true,
//RequireUppercase = true,
};
// Configure user lockout defaults
UserLockoutEnabledByDefault = false;
DefaultAccountLockoutTimeSpan = TimeSpan.FromMinutes(5);
MaxFailedAccessAttemptsBeforeLockout = 5;
// Register two factor authentication providers. This application uses Phone and Emails as a step of receiving a code for verifying the user
// You can write your own provider and plug it in here.
RegisterTwoFactorProvider("Phone Code", new PhoneNumberTokenProvider <User>
{
MessageFormat = "Your security code is {0}"
});
var emailTokenProvider = new EmailTokenProvider <User>
{
Subject = "Security Code",
BodyFormat = "Your security code is {0}"
};
RegisterTwoFactorProvider("Email Code", emailTokenProvider);
EmailService = _emailService as IIdentityMessageService;
SmsService = _smsService as IIdentityMessageService;
var dataProtectionProvider = _options.DataProtectionProvider;
if (dataProtectionProvider == null)
{
dataProtectionProvider = new DpapiDataProtectionProvider("CAFE.Web");
}
UserTokenProvider =
new DataProtectorTokenProvider <User>(dataProtectionProvider.Create("ASP.NET Identity"));
}
public override async Task <string> GenerateTwoFactorTokenAsync(UserModel user, string tokenProvider)
{
using var dbContext = new GameDbContext(_dbContextOptions);
var emailTokenProvider = new EmailTokenProvider <UserModel>();
var token = await emailTokenProvider.GenerateAsync("TwoFactor", this, user);
dbContext.TwoFactorCodeModels.Add(new TwoFactorCodeModel {
TokenCode = token, TokenProvider = tokenProvider, UserId = user.Id
});
if (dbContext.ChangeTracker.HasChanges())
{
await dbContext.SaveChangesAsync();
}
return(token);
}
public static UserManager <ApplicationUser> CreateUserManager([CallerMemberName] string name = null)
{
var database = CreateDatabase(name);
var store = new UserStore <ApplicationUser>(database);
var tokenGenerator = new EmailTokenProvider <ApplicationUser>();
var userManager = new UserManager <ApplicationUser>(store, null, new PasswordHasher <ApplicationUser>(), null,
new[] { new PasswordValidator <ApplicationUser>(new IdentityErrorDescriber()) }, null, new IdentityErrorDescriber(), null,
new NullLogger <UserManager <ApplicationUser> >());
userManager.Options.Password.RequireDigit = false;
userManager.Options.Password.RequireLowercase = false;
userManager.Options.Password.RequireNonAlphanumeric = false;
userManager.Options.Password.RequireUppercase = false;
userManager.Options.Password.RequiredLength = 1;
userManager.RegisterTokenProvider(TokenOptions.DefaultProvider, tokenGenerator);
return(userManager);
}
public AccountController(
UserManager <ApplicationUser> userManager,
RoleManager <IdentityRole> roleManager,
SignInManager <ApplicationUser> signInManager,
IOptions <IdentityCookieOptions> identityCookieOptions,
EmailTokenProvider <ApplicationUser> tokenProvider,
IEmailSender emailSender,
ISmsSender smsSender,
ILoggerFactory loggerFactory,
ApplicationDbContext dbContext)
{
_userManager = userManager;
_roleManager = roleManager;
_signInManager = signInManager;
_externalCookieScheme = identityCookieOptions.Value.ExternalCookieAuthenticationScheme;
_emailSender = emailSender;
_smsSender = smsSender;
_logger = loggerFactory.CreateLogger <AccountController>();
_dbContext = dbContext;
}
private static void RegisterUserManager(IWindsorContainer container, string connectionString)
{
var dbContext = GetDbContext(connectionString);
IUserStore <ApplicationUser> userStore = new UserStore <ApplicationUser, ApplicationRole, ApplicationDbContext, Guid>(dbContext);
IPasswordHasher <ApplicationUser> userHasher = new PasswordHasher <ApplicationUser>();
UserValidator <ApplicationUser> userValidator = new UserValidator <ApplicationUser>();
var validators = new UserValidator <ApplicationUser>[] { userValidator };
var userManager = new UserManager <ApplicationUser>(userStore, null, userHasher, validators, null, null, null, null, null);
// Set-up token providers.
IUserTwoFactorTokenProvider <ApplicationUser> tokenProvider = new EmailTokenProvider <ApplicationUser>();
userManager.RegisterTokenProvider("Default", tokenProvider);
IUserTwoFactorTokenProvider <ApplicationUser> phoneTokenProvider = new PhoneNumberTokenProvider <ApplicationUser>();
userManager.RegisterTokenProvider("PhoneTokenProvider", phoneTokenProvider);
container.Register(Component.For <UserManager <ApplicationUser> >().Instance(userManager));
}
public AppUserMananger(IUserStore <AppUser> store) : base(store)
{
// 配置用户名的验证逻辑
UserValidator = new UserValidator <AppUser>(this)
{
AllowOnlyAlphanumericUserNames = true,
RequireUniqueEmail = false
};
// 配置密码的验证逻辑
PasswordValidator = new PasswordValidator
{
RequiredLength = 6,
RequireNonLetterOrDigit = false,
RequireDigit = true,
RequireLowercase = true,
RequireUppercase = false
};
UserTokenProvider = new EmailTokenProvider <AppUser>();
}
/// <summary>
/// Creates a new instance of the class and configures its internals.
/// </summary>
/// <param name="DubaiCultureUserStore">User store passed onto the base class.</param>
public DubaiCultureUserManager(IDubaiCultureUserStore DubaiCultureUserStore) : base(DubaiCultureUserStore)
{
PasswordValidator = new PasswordValidator
{
RequireDigit = true,
RequiredLength = 8,
RequireLowercase = true,
RequireNonLetterOrDigit = true,
RequireUppercase = true
};
UserLockoutEnabledByDefault = false;
EmailService = new EmailService();
UserValidator = new UserValidator <DubaiCultureUser, int>(this)
{
RequireUniqueEmail = true
};
// Registration: Confirmed registration
UserTokenProvider = new EmailTokenProvider <DubaiCultureUser, int>();
}
public AppUserManager(IUserStore <AppUser, Guid> userStore, IServiceLogger logger)
: base(userStore)
{
_logger = logger;
ClaimsIdentityFactory = new AppClaimIdentityFactory();
UserValidator = new UserValidator <AppUser, Guid>(this)
{
AllowOnlyAlphanumericUserNames = false,
RequireUniqueEmail = true,
};
PasswordValidator = new PasswordValidator()
{
RequiredLength = 6,
RequireNonLetterOrDigit = false,
RequireDigit = true,
RequireLowercase = true,
RequireUppercase = true,
};
UserTokenProvider = new EmailTokenProvider <AppUser, Guid>();
}
private void ConfigureUserTokens()
{
UserTokenProvider = new EmailTokenProvider <RocamAppUser, string>();
}
public static async Task SeedAdmin(AdminSetupModel adminSetupModel, string defaultLocale, BaseDbContext dbContext)
{
var userStore = new UserStore <EformUser,
EformRole,
BaseDbContext,
int,
IdentityUserClaim <int>,
EformUserRole,
IdentityUserLogin <int>,
IdentityUserToken <int>,
IdentityRoleClaim <int> >(dbContext);
IPasswordHasher <EformUser> hasher = new PasswordHasher <EformUser>();
var validator = new UserValidator <EformUser>();
var validators = new List <UserValidator <EformUser> > {
validator
};
var userManager = new UserManager <EformUser>(userStore, null, hasher, validators, null, null, null,
null, null);
// Set-up token providers.
IUserTwoFactorTokenProvider <EformUser> tokenProvider = new EmailTokenProvider <EformUser>();
userManager.RegisterTokenProvider("Default", tokenProvider);
IUserTwoFactorTokenProvider <EformUser> phoneTokenProvider =
new PhoneNumberTokenProvider <EformUser>();
userManager.RegisterTokenProvider("PhoneTokenProvider", phoneTokenProvider);
// Roles
var roleStore = new RoleStore <EformRole, BaseDbContext, int>(dbContext);
var roleManager = new RoleManager <EformRole>(roleStore, null, null, null, null);
if (!await roleManager.RoleExistsAsync(EformRole.Admin))
{
await roleManager.CreateAsync(new EformRole { Name = EformRole.Admin });
}
if (!await roleManager.RoleExistsAsync(EformRole.User))
{
await roleManager.CreateAsync(new EformRole { Name = EformRole.User });
}
// Seed admin and demo users
var timeZoneString = "Europe/Copenhagen";
try
{
TimeZoneInfo.FindSystemTimeZoneById(timeZoneString);
}
catch
{
timeZoneString = "E. Europe Standard Time";
}
var adminUser = new EformUser
{
UserName = adminSetupModel.Email,
Email = adminSetupModel.Email,
FirstName = adminSetupModel.FirstName,
LastName = adminSetupModel.LastName,
Locale = string.IsNullOrEmpty(defaultLocale) ? LocaleNames.English : defaultLocale,
TimeZone = timeZoneString,
DarkTheme = true,
Formats = LocaleNames.German,
EmailConfirmed = true,
TwoFactorEnabled = false,
IsGoogleAuthenticatorEnabled = false
};
if (!userManager.Users.Any(x => x.Email.Equals(adminUser.Email)))
{
var createResult = await userManager.CreateAsync(adminUser,
adminSetupModel.Password);
if (!createResult.Succeeded)
{
throw new Exception("Could not create the user");
}
}
var user = userManager.Users.FirstOrDefault(x => x.Email.Equals(adminUser.Email));
if (!await userManager.IsInRoleAsync(user, EformRole.Admin))
{
await userManager.AddToRoleAsync(user, EformRole.Admin);
}
}
public TwoFactorValidator(ITranslator translator, IdentityUserManager identityUserManager, EmailTokenProvider emailProvider, SmsTokenProvider smsProvider, UserManager <ApplicationUser> manager)
{
m_translator = translator;
m_identityUserManager = identityUserManager;
m_userManager = manager;
m_tokenProviders = new Dictionary <string, TotpSecurityStampBasedTokenProvider <ApplicationUser> >
{
{ "Default", emailProvider }, //TODO make default provider configurable
{ EmailTokenProvider.ProviderName, emailProvider },
{ SmsTokenProvider.ProviderName, smsProvider },
};
}
