コード例 #1
0
        private static MembershipRebootConfiguration CreateMembershipRebootConfiguration(IAppBuilder app)
        {
            var config = new MembershipRebootConfiguration();

            // config.RequireAccountVerification = false;
            config.AddEventHandler(new DebuggerEventHandler());

            var appInfo = new OwinApplicationInformation(
                app,
                "Test",
                "Test Email Signature",
                "/UserAccount/Login",
                "/UserAccount/ChangeEmail/Confirm/",
                "/UserAccount/Register/Cancel/",
                "/UserAccount/PasswordReset/Confirm/");

            var emailFormatter = new EmailMessageFormatter(appInfo);

            // uncomment if you want email notifications -- also update smtp settings in web.config
            config.AddEventHandler(new EmailAccountEventsHandler(emailFormatter));
            // uncomment to enable SMS notifications -- also update TwilloSmsEventHandler class below
            //config.AddEventHandler(new TwilloSmsEventHandler(appinfo));

            // uncomment to ensure proper password complexity
            //config.ConfigurePasswordComplexity();

            return(config);
        }
        public static MembershipRebootConfiguration<CustomUserAccount> Create()
        {
            var settings = SecuritySettings.Instance;
            settings.MultiTenant = false;
            
            var config = new MembershipRebootConfiguration<CustomUserAccount>(settings);
            config.RegisterPasswordValidator(new PasswordValidator());
            config.ConfigurePasswordComplexity(5, 3);

            config.AddCommandHandler(new CustomClaimsMapper());

            var delivery = new SmtpMessageDelivery();

            var appinfo = new AspNetApplicationInformation("Test", "Test Email Signature",
                "UserAccount/Login",
                "UserAccount/ChangeEmail/Confirm/",
                "UserAccount/Register/Cancel/",
                "UserAccount/PasswordReset/Confirm/");
            var formatter = new CustomEmailMessageFormatter(appinfo);

            config.AddEventHandler(new EmailAccountEventsHandler<CustomUserAccount>(formatter, delivery));
            config.AddEventHandler(new AuthenticationAuditEventHandler());
            config.AddEventHandler(new NotifyAccountOwnerWhenTooManyFailedLoginAttempts());

            config.AddValidationHandler(new PasswordChanging());
            config.AddEventHandler(new PasswordChanged());

            return config;
        }
コード例 #3
0
 static Program()
 {
     config = new MembershipRebootConfiguration <CustomUserAccount>();
     config.PasswordHashingIterationCount = 50000;
     config.MultiTenant = false;
     // etc...
 }
        public static MembershipRebootConfiguration Create()
        {
            var config = new MembershipRebootConfiguration();

            config.RequireAccountVerification = false;

            config.AddEventHandler(new DebuggerEventHandler());

            var appinfo = new AspNetApplicationInformation("Test", "Test Email Signature",
                                                           "UserAccount/Login",
                                                           "UserAccount/ChangeEmail/Confirm/",
                                                           "UserAccount/Register/Cancel/",
                                                           "UserAccount/PasswordReset/Confirm/");
            var emailFormatter = new EmailMessageFormatter(appinfo);

            // uncomment if you want email notifications -- also update smtp settings in web.config
            config.AddEventHandler(new EmailAccountEventsHandler(emailFormatter));
            //config.AddEventHandler(new TwilloSmsEventHandler(appinfo));
            // set to false for production
            config.ConfigureAspNetCookieBasedTwoFactorAuthPolicy(debugging: true);

            // uncomment to ensure proper password complexity
            //config.ConfigurePasswordComplexity();

            return(config);
        }
コード例 #5
0
        public static MembershipRebootConfiguration Create()
        {
            var config = new MembershipRebootConfiguration();

            //config.RequireAccountVerification = false;
            config.AddEventHandler(new DebuggerEventHandler());

            var appinfo = new AspNetApplicationInformation("Test", "Test Email Signature",
                                                           "UserAccount/Login",
                                                           "UserAccount/ChangeEmail/Confirm/",
                                                           "UserAccount/Register/Cancel/",
                                                           "UserAccount/PasswordReset/Confirm/");

            var emailFormatter = new MyEmailFormatter2(appinfo);

            // uncomment if you want email notifications -- also update smtp settings in web.config
            config.AddEventHandler(new EmailAccountEventsHandler(emailFormatter));

            // uncomment to enable SMS notifications -- also update TwilloSmsEventHandler class below
            //config.AddEventHandler(new TwilloSmsEventHandler(appinfo));

            // uncomment to ensure proper password complexity
            //config.ConfigurePasswordComplexity();

            var debugging = false;

#if DEBUG
            debugging = true;
#endif
            // this config enables cookies to be issued once user logs in with mobile code
            config.ConfigureTwoFactorAuthenticationCookies(debugging);

            return(config);
        }
        public static MembershipRebootConfiguration <CustomUserAccount> Create()
        {
            var settings = SecuritySettings.Instance;

            settings.MultiTenant = false;

            var config = new MembershipRebootConfiguration <CustomUserAccount>(settings);

            config.RegisterPasswordValidator(new PasswordValidator());
            config.ConfigurePasswordComplexity(5, 3);

            config.AddCommandHandler(new CustomClaimsMapper());

            var delivery = new SmtpMessageDelivery();

            var appinfo = new AspNetApplicationInformation("Test", "Test Email Signature",
                                                           "UserAccount/Login",
                                                           "UserAccount/ChangeEmail/Confirm/",
                                                           "UserAccount/Register/Cancel/",
                                                           "UserAccount/PasswordReset/Confirm/");
            var formatter = new CustomEmailMessageFormatter(appinfo);

            config.AddEventHandler(new EmailAccountEventsHandler <CustomUserAccount>(formatter, delivery));
            config.AddEventHandler(new AuthenticationAuditEventHandler());
            config.AddEventHandler(new NotifyAccountOwnerWhenTooManyFailedLoginAttempts());

            config.AddValidationHandler(new PasswordChanging());
            config.AddEventHandler(new PasswordChanged());
            config.AddCommandHandler(new CustomValidationMessages());

            return(config);
        }
コード例 #7
0
        public static void ConfigureSolutionFormsProviders(this IServiceCollection services, ApplicationAccountInformation appAccountInformation, StmpDeliveryConfig smtpConfig)
        {
            services.AddTransient <IHttpContextAccessor, HttpContextAccessor>();
            services.AddSingleton(p => RavenContext.DocumentStore);
            //services.AddSingleton(p => new MembershipRebootConfiguration<ApplicationUser>(p.GetService<IOptions<SecuritySettings>>().Value));
            services.AddSingleton(p =>
            {
                var contextAccessor = p.GetService <IHttpContextAccessor>();
                var appInfo         = new NewAspNetApplicationInformation(contextAccessor, "Solution Forms", "Solution Forms Team", appAccountInformation.RelativeLoginUrl, appAccountInformation.RelativeConfirmChangeEmailUrl, appAccountInformation.RelativeCancelVerificationUrl, appAccountInformation.RelativeConfirmPasswordResetUrl)
                {
                    CancelVerificationUrl   = appAccountInformation.CancelVerificationUrl,
                    ConfirmChangeEmailUrl   = appAccountInformation.ConfirmChangeEmailUrl,
                    ConfirmPasswordResetUrl = appAccountInformation.ConfirmChangeEmailUrl,
                };
                var config = new MembershipRebootConfiguration <ApplicationUser>(p.GetService <IOptions <SecuritySettings> >().Value);
                //todo: get application URL builder from services and pass into appInfo constructor.
                config.AddEventHandler(new EmailAccountEventsHandler <ApplicationUser>(new EmailMessageFormatter <ApplicationUser>(appInfo), new SmtpMessageDelivery(smtpConfig)));
                return(config);
            });
            services.AddScoped <UserAccountService <ApplicationUser> >();
            services.AddScoped <DataFormsProvider>();
            services.AddScoped <DataSourcesProvider>();
            services.AddScoped <IUserAccountRepository <ApplicationUser>, MembershipProvider>();
            services.AddScoped <AuthenticationService <ApplicationUser> >(provider =>
                                                                          new AspNetAuthenticationService(
                                                                              provider.GetService <UserAccountService <ApplicationUser> >(),
                                                                              provider.GetService <IHttpContextAccessor>().HttpContext));

            services.AddScoped <TenantProvider>();
            services.AddScoped <PaymentProvider>();
        }
        public static MembershipRebootConfiguration Create()
        {
            var settings = SecuritySettings.FromConfiguration();
            var config   = new MembershipRebootConfiguration(settings);

            var appinfo = new AspNetApplicationInformation("Test", "Test Email Signature",
                                                           "UserAccount/Login",
                                                           "UserAccount/Register/Confirm/",
                                                           "UserAccount/Register/Cancel/",
                                                           "UserAccount/PasswordReset/Confirm/",
                                                           "UserAccount/ChangeEmail/Confirm/");
            var emailFormatter = new EmailMessageFormatter(appinfo);

            if (settings.RequireAccountVerification)
            {
                // uncomment if you want email notifications -- also update smtp settings in web.config
                //config.AddEventHandler(new EmailAccountCreatedEventHandler(emailFormatter));
            }
            // uncomment if you want email notifications -- also update smtp settings in web.config
            //config.AddEventHandler(new EmailAccountEventsHandler(emailFormatter));
            config.AddEventHandler(new TwilloSmsEventHandler(appinfo));
            config.ConfigureAspNetCookieBasedTwoFactorAuthPolicy();

            return(config);
        }
        public static MembershipRebootConfiguration Create()
        {
            var config = new MembershipRebootConfiguration();
            //config.RequireAccountVerification = false;
            config.AddEventHandler(new DebuggerEventHandler());

            var appinfo = new AspNetApplicationInformation("Test", "Test Email Signature",
                "UserAccount/Login", 
                "UserAccount/ChangeEmail/Confirm/",
                "UserAccount/Register/Cancel/",
                "UserAccount/PasswordReset/Confirm/");
            var emailFormatter = new EmailMessageFormatter(appinfo);
            // uncomment if you want email notifications -- also update smtp settings in web.config
            config.AddEventHandler(new EmailAccountEventsHandler(emailFormatter));

            // uncomment to enable SMS notifications -- also update TwilloSmsEventHandler class below
            //config.AddEventHandler(new TwilloSmsEventHandler(appinfo));
            
            // uncomment to ensure proper password complexity
            //config.ConfigurePasswordComplexity();

            var debugging = false;
#if DEBUG
            debugging = true;
#endif
            // this config enables cookies to be issued once user logs in with mobile code
            config.ConfigureTwoFactorAuthenticationCookies(debugging);

            return config;
        }
        public static MembershipRebootConfiguration Create()
        {
            var settings = SecuritySettings.Instance;
            var config = new MembershipRebootConfiguration(settings, new DelegateFactory(()=>new DefaultUserAccountRepository(settings.ConnectionStringName)));

            var appinfo = new Lazy<ApplicationInformation>(() =>
            {
                // build URL
                var baseUrl = HttpContext.Current.GetApplicationUrl();
                // area name
                baseUrl += "UserAccount/";

                return new ApplicationInformation
                {
                    ApplicationName = "Test",
                    LoginUrl = baseUrl + "Login",
                    VerifyAccountUrl = baseUrl + "Register/Confirm/",
                    CancelNewAccountUrl = baseUrl + "Register/Cancel/",
                    ConfirmPasswordResetUrl = baseUrl + "PasswordReset/Confirm/",
                    ConfirmChangeEmailUrl = baseUrl + "ChangeEmail/Confirm/"
                };
            });
            var emailFormatter = new EmailMessageFormatter(appinfo);
            if (settings.RequireAccountVerification)
            {
                //config.AddEventHandler(new EmailAccountCreatedEventHandler(emailFormatter));
            }
            //config.AddEventHandler(new EmailAccountEventsHandler(emailFormatter));
            config.AddEventHandler(new TwilloSmsEventHandler(appinfo));

            config.ConfigureAspNetCookieBasedTwoFactorAuthPolicy();
            
            return config;
        }
        public static MembershipRebootConfiguration Create()
        {
            var settings = SecuritySettings.FromConfiguration();
            var config = new MembershipRebootConfiguration(settings);

            var appinfo = new AspNetApplicationInformation("Test", "Test Email Signature",
                "UserAccount/Login", 
                "UserAccount/Register/Confirm/",
                "UserAccount/Register/Cancel/",
                "UserAccount/PasswordReset/Confirm/",
                "UserAccount/ChangeEmail/Confirm/");
            var emailFormatter = new EmailMessageFormatter(appinfo);
            if (settings.RequireAccountVerification)
            {
                // uncomment if you want email notifications -- also update smtp settings in web.config
                //config.AddEventHandler(new EmailAccountCreatedEventHandler(emailFormatter));
            }
            // uncomment if you want email notifications -- also update smtp settings in web.config
            //config.AddEventHandler(new EmailAccountEventsHandler(emailFormatter));
            //config.AddEventHandler(new TwilloSmsEventHandler(appinfo));
            // set to false for production
            config.ConfigureAspNetCookieBasedTwoFactorAuthPolicy(debugging:true);

            // uncomment to ensure proper password complexity
            //config.ConfigurePasswordComplexity();
            
            return config;
        }
コード例 #12
0
        public static MembershipRebootConfiguration Create()
        {
            var settings = SecuritySettings.Instance;
            var config   = new MembershipRebootConfiguration(settings, new DelegateFactory(() => new DefaultUserAccountRepository(settings.ConnectionStringName)));

            var appinfo = new Lazy <ApplicationInformation>(() =>
            {
                // build URL
                var baseUrl = HttpContext.Current.GetApplicationUrl();
                // area name
                baseUrl += "UserAccount/";

                return(new ApplicationInformation
                {
                    ApplicationName = "Test",
                    LoginUrl = baseUrl + "Login",
                    VerifyAccountUrl = baseUrl + "Register/Confirm/",
                    CancelNewAccountUrl = baseUrl + "Register/Cancel/",
                    ConfirmPasswordResetUrl = baseUrl + "PasswordReset/Confirm/",
                    ConfirmChangeEmailUrl = baseUrl + "ChangeEmail/Confirm/"
                });
            });
            var emailFormatter = new EmailMessageFormatter(appinfo);

            if (settings.RequireAccountVerification)
            {
                //config.AddEventHandler(new EmailAccountCreatedEventHandler(emailFormatter));
            }
            //config.AddEventHandler(new EmailAccountEventsHandler(emailFormatter));
            config.AddEventHandler(new TwilloSmsEventHandler(appinfo));

            config.ConfigureAspNetCookieBasedTwoFactorAuthPolicy();

            return(config);
        }
        public MockUserAccountService()
        {
            this.UserAccountRepository = new Mock<IUserAccountRepository>();
            this.UserAccountRepository.Setup(x => x.Create()).Returns(new UserAccount());

            this.SecuritySettings = new SecuritySettings();
            Configuration = new MembershipRebootConfiguration(this.SecuritySettings, this.UserAccountRepository.Object);
        }
コード例 #14
0
        public static MembershipRebootConfiguration <CustomUser> Create()
        {
            var settings = SecuritySettings.Instance;

            var config = new MembershipRebootConfiguration <CustomUser>(settings);

            return(config);
        }
コード例 #15
0
        static UserManagerFactory()
        {
            System.Data.Entity.Database.SetInitializer(new System.Data.Entity.MigrateDatabaseToLatestVersion <DefaultMembershipRebootDatabase, BrockAllen.MembershipReboot.Ef.Migrations.Configuration>());

            config = new MembershipRebootConfiguration();
            config.PasswordHashingIterationCount = 10000;
            config.RequireAccountVerification    = false;
        }
コード例 #16
0
 public void Init()
 {
     securitySettings = new SecuritySettings();
     securitySettings.PasswordHashingIterationCount = 1; // tests will run faster
     configuration = new MembershipRebootConfiguration(securitySettings);
     repository = new FakeUserAccountRepository(); 
     subject = new UserAccountService(configuration, repository);
 }
コード例 #17
0
        public MockUserAccountService()
        {
            this.UserAccountRepository = new Mock <IUserAccountRepository>();
            this.UserAccountRepository.Setup(x => x.Create()).Returns(new UserAccount());

            this.SecuritySettings = new SecuritySettings();
            Configuration         = new MembershipRebootConfiguration(this.SecuritySettings, this.UserAccountRepository.Object);
        }
コード例 #18
0
 public static void ConfigurePasswordComplexity(this MembershipRebootConfiguration config)
 {
     if (config == null)
     {
         throw new ArgumentNullException("config");
     }
     config.RegisterPasswordValidator(new PasswordComplexityValidator());
 }
コード例 #19
0
 public static void ConfigurePasswordComplexity(this MembershipRebootConfiguration config, int minimumLength, int minimumNumberOfComplexityRules)
 {
     if (config == null)
     {
         throw new ArgumentNullException("config");
     }
     config.RegisterPasswordValidator(new PasswordComplexityValidator(minimumLength, minimumNumberOfComplexityRules));
 }
コード例 #20
0
        public static void RegisterEmailValidator(this MembershipRebootConfiguration config, Func <IUserAccountService, UserAccount, string, ValidationResult> func)

        {
            if (config == null)
            {
                throw new ArgumentNullException("config");
            }
            config.RegisterEmailValidator(new DelegateValidator(func));
        }
コード例 #21
0
        public static void ConfigureAspNetCookieBasedTwoFactorAuthPolicy(this MembershipRebootConfiguration config)
        {
            if (config == null)
            {
                throw new ArgumentNullException("config");
            }

            config.ConfigureCookieBasedTwoFactorAuthPolicy(new AspNetCookieBasedTwoFactorAuthPolicy());
        }
コード例 #22
0
        static MembershipRebootUserServiceFactory()
        {
            System.Data.Entity.Database.SetInitializer(new System.Data.Entity.MigrateDatabaseToLatestVersion <DefaultMembershipRebootDatabase, BrockAllen.MembershipReboot.Ef.Migrations.Configuration>());

            config = new MembershipRebootConfiguration();
            config.PasswordHashingIterationCount  = 50000;
            config.AllowLoginAfterAccountCreation = true;
            config.RequireAccountVerification     = false;
        }
コード例 #23
0
        public static void AddEventHandler <TEvent>(this MembershipRebootConfiguration config, Action <TEvent> action)

            where TEvent : IEvent
        {
            if (config == null)
            {
                throw new ArgumentNullException("config");
            }
            config.AddEventHandler(new DelegateEventHandler <TEvent>(action));
        }
コード例 #24
0
        public static void AddCommandHandler <TCommand>(this MembershipRebootConfiguration config, Action <TCommand> action)

            where TCommand : ICommand
        {
            if (config == null)
            {
                throw new ArgumentNullException("config");
            }
            config.AddCommandHandler(new DelegateCommandHandler <TCommand>(action));
        }
コード例 #25
0
        public IdentityRepository()
        {
            var settings = SecuritySettings.FromConfiguration();

            settings.RequireAccountVerification = false;
            var config = new MembershipRebootConfiguration(settings);

            this.userSvc  = new UserAccountService(config, new BrockAllen.MembershipReboot.Ef.DefaultUserAccountRepository());
            this.groupSvc = new GroupService(new BrockAllen.MembershipReboot.Ef.DefaultGroupRepository());
        }
コード例 #26
0
        public static MembershipRebootConfiguration CreateMembershipRebootConfiguration()
        {
            var settings = SecuritySettings.Instance;

            settings.MultiTenant = false;

            var config = new MembershipRebootConfiguration(settings);

            return(config);
        }
コード例 #27
0
        public void Init()
        {
            oldIterations = SecuritySettings.Instance.PasswordHashingIterationCount;
            SecuritySettings.Instance.PasswordHashingIterationCount = 1; // tests will run faster

            securitySettings = new SecuritySettings();
            configuration    = new MembershipRebootConfiguration(securitySettings);
            repository       = new FakeUserAccountRepository();
            subject          = new UserAccountService(configuration, repository);
        }
コード例 #28
0
        public static MembershipRebootConfiguration CreateMembershipRebootConfiguration()
        {
            var settings = SecuritySettings.Instance;

            settings.MultiTenant = false;

            var config = new MembershipRebootConfiguration(settings, new DelegateFactory(() => new DefaultUserAccountRepository(settings.ConnectionStringName)));

            return(config);
        }
コード例 #29
0
        public void Init()
        {
            oldIterations = SecuritySettings.Instance.PasswordHashingIterationCount;
            SecuritySettings.Instance.PasswordHashingIterationCount = 1; // tests will run faster

            configuration = new MembershipRebootConfiguration();
            key = new KeyNotification();
            configuration.AddEventHandler(key);
            repository = new FakeUserAccountRepository();
            subject = new TestUserAccountService(configuration, repository);
        }
 public void EmailNotUnique_EmailIsUsername_FailsValidation()
 {
     var subject = new MembershipRebootConfiguration();
     subject.EmailIsUnique = false;
     subject.EmailIsUsername = true;
     try
     {
         subject.Validate();
         Assert.Fail("Expected Exception");
     }
     catch (InvalidOperationException) { }
 }
        protected override IIdentityManagerService CreateIdentityManager()
        {
            var config = new MembershipRebootConfiguration <TestUserAccount>();

            config.RequireAccountVerification    = false;
            config.PasswordHashingIterationCount = 100;

            var repository = new TestUserAccountRepository();

            userAccountService = new UserAccountService <TestUserAccount>(config, repository);
            return(new IdentityManagerService <TestUserAccount>(userAccountService, repository));
        }
コード例 #32
0
ファイル: BootStrapper.cs プロジェクト: retslig/ANDP
        private static void BuildUnityContainer()
        {
            Container.AddNewExtension <DisposableStrategyExtension>();

            RegisterCommonMapper();

            //Entities
            //Container.RegisterType<IANDP_Engine_Entities, ANDP_Engine_Entities>(
            //    new HierarchicalLifetimeManager(), new InjectionFactory(c =>
            //    {
            //        var context = c.Resolve<HttpContextBase>();
            //        var tenantId = context.User.Identity.Name;
            //        return new ANDP_Engine_Entities(AndpEntitiesBootstrapper().ConnectionString, tenantId);
            //    }));

            //Container.RegisterType<IANDP_Order_Entities, ANDP_Order_Entities>(
            //    new HierarchicalLifetimeManager(), new InjectionFactory(c =>
            //    {
            //        var context = c.Resolve<HttpContextBase>();
            //        var tenantId = context.User.Identity.Name;
            //        return new ANDP_Order_Entities(AndpEntitiesBootstrapper().ConnectionString, tenantId);
            //    }));

            //Authentication Settings for Token support
            RegisterAuthSettings();

            //Not necessary for multi-tenant architecture.  Common schema.
            Container.RegisterType <ICommon_Entities, Common_Entities>(new HierarchicalLifetimeManager(), new InjectionConstructor(AndpEntitiesBootstrapper().ConnectionString));
            Container.RegisterType <ICommon_LanguageResource_Entities, Common_LanguageResource_Entities>(new HierarchicalLifetimeManager(), new InjectionConstructor(AndpEntitiesBootstrapper().ConnectionString));

            var config = new MembershipRebootConfiguration
            {
                PasswordHashingIterationCount = 10000,
                RequireAccountVerification    = false,
                //config.DefaultTenant = "",
                MultiTenant = true
            };

            //MembershipReboot Stuff
            Container.RegisterType <IUserAccountQuery, DefaultUserAccountRepository>(new DisposingTransientLifetimeManager());

            //Repos
            Container.RegisterType <DefaultMembershipRebootDatabase, DefaultMembershipRebootDatabase>(new DisposingTransientLifetimeManager(), new InjectionConstructor(AuthEntitiesBootstrapper().ConnectionString));
            Container.RegisterType <IUserAccountRepository, DefaultUserAccountRepository>(new DisposingTransientLifetimeManager());
            Container.RegisterType <ICommonRepository, CommonRepository>(new HierarchicalLifetimeManager());
            Container.RegisterType <ILanguageResourceRepository, LanguageResourceRepository>(new ExternallyControlledLifetimeManager());

            //Services
            Container.RegisterType <UserAccountService, UserAccountService>(new DisposingTransientLifetimeManager(), new InjectionConstructor(config, Container.Resolve <IUserAccountRepository>()));
            Container.RegisterType <AuthenticationService, SamAuthenticationService>(new DisposingTransientLifetimeManager());
            Container.RegisterType <ILogger, NLogWriterService>(new HierarchicalLifetimeManager(), new InjectionConstructor(AndpEntitiesBootstrapper()));
            Container.RegisterType <ILanguageResourceService, LanguageResourceService>(new ExternallyControlledLifetimeManager(), new InjectionConstructor(Container.Resolve <ILanguageResourceRepository>(), Container.Resolve <ICommonMapper>(), "en-US"));
        }
コード例 #33
0
        public void Init()
        {
            oldIterations = SecuritySettings.Instance.PasswordHashingIterationCount;
            SecuritySettings.Instance.PasswordHashingIterationCount = 1; // tests will run faster

            configuration = new MembershipRebootConfiguration();
            key           = new KeyNotification();
            configuration.AddEventHandler(key);
            repository         = new FakeUserAccountRepository();
            userAccountService = new UserAccountService(configuration, repository);

            subject = new TestAuthenticationService(userAccountService);
        }
コード例 #34
0
        public void EmailNotUnique_EmailIsUsername_FailsValidation()
        {
            var subject = new MembershipRebootConfiguration();

            subject.EmailIsUnique   = false;
            subject.EmailIsUsername = true;
            try
            {
                subject.Validate();
                Assert.Fail("Expected Exception");
            }
            catch (InvalidOperationException) { }
        }
        public static MembershipRebootConfiguration Create()
        {
            var config = new MembershipRebootConfiguration
            {
                MultiTenant = true,
                RequireAccountVerification     = true,
                EmailIsUsername                = true,
                AllowLoginAfterAccountCreation = true
            };

            config.AddEventHandler(new DebuggerEventHandler());

            return(config);
        }
        public void Init()
        {
            SecuritySettings.Instance.PasswordHashingIterationCount = 1; // tests will run faster

            configuration = new MembershipRebootConfiguration
            {
                RequireAccountVerification = false
            };
            key = new KeyNotification();
            configuration.AddEventHandler(key);
            repository = new FakeUserAccountRepository();
            userAccountService = new UserAccountService(configuration, repository);

            subject = new TestAuthenticationService(userAccountService);
        }
コード例 #37
0
        public void Init()
        {
            SecuritySettings.Instance.PasswordHashingIterationCount = 1; // tests will run faster

            configuration = new MembershipRebootConfiguration
            {
                RequireAccountVerification = false
            };
            accountCreatedEvent = CaptureLatestEvent.For <AccountCreatedEvent <UserAccount> >();
            configuration.AddEventHandler(accountCreatedEvent);
            configuration.AddCommandHandler(new TestMapClaimsToAccountHandler());
            repository         = new FakeUserAccountRepository();
            userAccountService = new UserAccountService(configuration, repository);

            subject = new TestAuthenticationService(userAccountService);
        }
コード例 #38
0
        public void Init()
        {
            SecuritySettings.Instance.PasswordHashingIterationCount = 1; // tests will run faster

            configuration = new MembershipRebootConfiguration
            {
                RequireAccountVerification = false,
                PasswordResetFrequency     = 1 // every day
            };
            configuration.AddEventHandler(new KeyNotification());
            configuration.AddCommandHandler(new TestMapClaimsFromAccount());
            repository         = new FakeUserAccountRepository();
            userAccountService = new UserAccountService(configuration, repository);

            subject = new TestAuthenticationService(userAccountService);
        }
コード例 #39
0
        public IdentityRepository()
        {
            var settings = SecuritySettings.FromConfiguration();

            settings.RequireAccountVerification    = false;
            settings.PasswordHashingIterationCount = 50000;
            var config = new MembershipRebootConfiguration(settings);
            var uarepo = new BrockAllen.MembershipReboot.Ef.DefaultUserAccountRepository();

            this.userSvc   = new UserAccountService(config, uarepo);
            this.userQuery = uarepo;

            var grpRepo = new BrockAllen.MembershipReboot.Ef.DefaultGroupRepository();

            this.groupSvc   = new GroupService(config.DefaultTenant, grpRepo);
            this.groupQuery = grpRepo;
        }
        public static MembershipRebootConfiguration Create()
        {
            var config = new MembershipRebootConfiguration();
            //config.RequireAccountVerification = false;

            config.AddEventHandler(new DebuggerEventHandler());

            var appinfo = new AspNetApplicationInformation("Test", "Test Email Signature",
                "UserAccount/Login", 
                "UserAccount/ChangeEmail/Confirm/",
                "UserAccount/Register/Cancel/",
                "UserAccount/PasswordReset/Confirm/");
            var emailFormatter = new EmailMessageFormatter(appinfo);
            // uncomment if you want email notifications -- also update smtp settings in web.config
            config.AddEventHandler(new EmailAccountEventsHandler(emailFormatter));
            //config.AddEventHandler(new TwilloSmsEventHandler(appinfo));
            // uncomment to ensure proper password complexity
            //config.ConfigurePasswordComplexity();
            
            return config;
        }
        public static MembershipRebootConfiguration Create()
        {
            var settings = SecuritySettings.Instance;
            settings.MultiTenant = false;
            
            var config = new MembershipRebootConfiguration(settings, ()=>new CustomRepository());
            config.RegisterPasswordValidator(new PasswordValidator());

            var delivery = new SmtpMessageDelivery();
            var formatter = new CustomEmailMessageFormatter(new Lazy<ApplicationInformation>(() =>
            {
                // build URL
                var baseUrl = HttpContext.Current.GetApplicationUrl();
                // area name
                baseUrl += "UserAccount/";

                return new ApplicationInformation
                {
                    ApplicationName = "Test",
                    LoginUrl = baseUrl + "Login",
                    VerifyAccountUrl = baseUrl + "Register/Confirm/",
                    CancelNewAccountUrl = baseUrl + "Register/Cancel/",
                    ConfirmPasswordResetUrl = baseUrl + "PasswordReset/Confirm/",
                    ConfirmChangeEmailUrl = baseUrl + "ChangeEmail/Confirm/"
                };
            }));

            if (settings.RequireAccountVerification)
            {
                config.AddEventHandler(new EmailAccountCreatedEventHandler(formatter, delivery));
            }
            config.AddEventHandler(new EmailAccountEventsHandler(formatter, delivery));
            config.AddEventHandler(new AuthenticationAuditEventHandler());
            config.AddEventHandler(new NotifyAccountOwnerWhenTooManyFailedLoginAttempts());

            return config;
        }
 public TestUserAccountService(MembershipRebootConfiguration configuration, IUserAccountRepository userRepository)
     : base(configuration, userRepository)
 {
 }