public void InitializeMembershipProviderFromConfigEntry(MembershipProvider result,
IEnumerable<KeyValuePair<string, string>> simulatedAppConfigSettings)
{
NameValueCollection nameValueCollection = null;
MembershipSection membership = ConfigurationManager.GetSection("system.web/membership") as MembershipSection;
foreach (ProviderSettings settings in membership.Providers)
{
if (settings.Name == FixtureConstants.NameOfConfiguredMembershipProvider)
{
nameValueCollection = new NameValueCollection(settings.Parameters);
break;
}
}
if (nameValueCollection == null)
{
throw new Exception("Configuration not found for membership provider RavenDBMembership.");
}
nameValueCollection["connectionStringName"] = "StubConnectionString";
foreach (var kvp in simulatedAppConfigSettings)
{
ValidateConfigurationValue(kvp.Key, kvp.Value);
nameValueCollection.Set(kvp.Key, kvp.Value);
}
result.Initialize(FixtureConstants.NameOfConfiguredMembershipProvider, nameValueCollection);
}
public DefaultProviderSwitcher(
MembershipProviderAccessor membershipProviderAccessor,
RoleProviderAccessor roleProviderAccessor,
MembershipProvider provider,
RoleProvider roleProvider)
{
Condition.Requires(membershipProviderAccessor, "membershipProviderAccessor").IsNotNull();
Condition.Requires(roleProviderAccessor, "roleProviderAccessor").IsNotNull();
Condition.Requires(provider, "provider").IsNotNull();
Condition.Requires(roleProvider, "roleProvider").IsNotNull();
this.membershipProviderAccessor = membershipProviderAccessor;
this.roleProviderAccessor = roleProviderAccessor;
this.originalMembershipInitializedDefault =
membershipProviderAccessor.SetInitializedDefaultProviderAndReturnOriginalValue(true);
this.originalMembershipInitialized = membershipProviderAccessor.SetInitializedAndReturnOriginalValue(true);
this.originalMembershipProvider = membershipProviderAccessor.SetProviderAndReturnOriginalValue(provider);
this.originalRoleEnabledInitialized = roleProviderAccessor.SetEnabledAndReturnOriginalValue(true);
this.originalRoleProviders =
roleProviderAccessor.SetProvidersAndReturnOriginalValue(new RoleProviderCollection());
this.originalRoleInitializedDefault =
roleProviderAccessor.SetInitializedDefaultProviderAndReturnOriginalValue(true);
this.originalRoleInitialized = roleProviderAccessor.SetInitializedAndReturnOriginalValue(true);
this.originalRoleProvider = roleProviderAccessor.SetProviderAndReturnOriginalValue(roleProvider);
}
public AccountMembershipService(MembershipProvider provider)
{
if (provider == null)
throw new ArgumentNullException("provider");
_provider = provider;
}
public MembershipService()
{
if (Membership.Provider is MonsterMembershipProvider)
Provider = Membership.Provider;
else
throw new InvalidOperationException("Membership provider not supported");
}
public AuthenticationService(MembershipProvider membershipProvider)
{
_membershipProvider = membershipProvider
?? Membership.Provider;
MinPasswordLength = _membershipProvider.MinRequiredPasswordLength;
}
public SQLiteFacebookMembershipProvider(string connectionString, string tableName, MembershipProvider membershipProvider)
{
_connectionString = connectionString;
_tableName = tableName ?? "facebook_users";
_membershipProvider = membershipProvider;
// we cound had done _membershipProvider = membershipProvider ?? Membership.Provider
// but that wouldn't allow to work under client profile
}
public static UserNamePasswordValidator CreateMembershipProviderValidator(MembershipProvider provider)
{
if (provider == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("provider");
}
return new MembershipProviderValidator(provider);
}
private static SimpleMembershipProvider CreateDefaultSimpleMembershipProvider(string name, MembershipProvider currentDefault)
{
MembershipProvider previousProvider = currentDefault;
SimpleMembershipProvider provider = new SimpleMembershipProvider(previousProvider);
NameValueCollection config = new NameValueCollection();
provider.Initialize(name, config);
return provider;
}
public MySqlSimpleMembershipProvider(MembershipProvider previousProvider)
{
_prevProvider = previousProvider;
if (_prevProvider != null)
{
_prevProvider.ValidatingPassword += delegate(object sender, ValidatePasswordEventArgs args) { this.OnValidatingPassword(args); };
}
}
public WebValidateUserPolicy(MembershipProvider provider)
: base((IMemberShipProvider)provider)
{
this.MaxInvalidPasswordAttempts = provider.MaxInvalidPasswordAttempts;
this.PasswordAttemptWindow = provider.PasswordAttemptWindow;
this.PasswordStrengthRegularExpression = provider.PasswordStrengthRegularExpression;
this.MinRequiredPasswordLength = provider.MinRequiredPasswordLength;
}
public ClientFormsIdentity (string name, string password, MembershipProvider provider, string authenticationType, bool isAuthenticated, CookieContainer authenticationCookies)
{
Password = password;
Name = name;
Provider = provider;
AuthenticationType = authenticationType;
IsAuthenticated = isAuthenticated;
AuthenticationCookies = authenticationCookies;
}
public static RequestInterceptor Create(string realm, MembershipProvider membershipProvider)
{
var basicAuthenticationCredentialsExtractor = new BasicAuthenticationCredentialsExtractor(new Base64Decoder(), new DecodedCredentialsExtractor());
var httpRequestAuthorizationExtractor = new AuthorizationStringExtractor();
var responseMessageFactory = new ResponseMessageFactory(realm);
var serviceSecurityContextFactory = new ServiceSecurityContextFactory(new AuthorizationPolicyFactory());
var basicAuthenticationManager = new BasicAuthenticationManager(basicAuthenticationCredentialsExtractor, httpRequestAuthorizationExtractor, membershipProvider, responseMessageFactory, serviceSecurityContextFactory);
return new BasicAuthenticationInterceptor(basicAuthenticationManager);
}
public FakeMembershipProviderTest()
{
this.localProvider = Substitute.For<MembershipProvider>();
this.provider = new FakeMembershipProvider();
this.provider.LocalProvider.Value = this.localProvider;
this.user = new MembershipUser("fake", UserName, new Guid(), null, null, null, true, false, DateTime.MinValue,
DateTime.Now, DateTime.Now, DateTime.MinValue, DateTime.MinValue);
}
public ClientFormsIdentity(string name, string password, MembershipProvider provider, string authenticationType, bool isAuthenticated, CookieContainer authenticationCookies)
{
_Name = name;
_AuthenticationType = authenticationType;
_IsAuthenticated = isAuthenticated;
_AuthenticationCookies = authenticationCookies;
_Password = GetSecureStringFromString(password);
_Provider = provider;
}
public SimpleMembershipProvider(MembershipProvider previousProvider) {
_previousProvider = previousProvider;
if (_previousProvider != null) {
_previousProvider.ValidatingPassword += (sender, args) => {
if (!InitializeCalled) {
OnValidatingPassword(args);
}
};
}
}
public override void PostInitializeUpdate(MembershipProvider provider)
{
var connectionStringProperty = typeof(SqlMembershipProvider).GetField("_sqlConnectionString",
BindingFlags.NonPublic |
BindingFlags.Instance);
Assert.That(connectionStringProperty, Is.Not.Null);
connectionStringProperty.SetValue(provider, DatabaseInitialization.GetConnectionStringFor(FixtureConstants.DatabaseName));
}
public void Setup()
{
DalCfg = new DalConfiguration();
DalCfg.Configure();
SessionFactory = DalCfg.getSessionFactory();
Session = SessionFactory.OpenSession();
p = new WallBackend.Providers.nHibernateMembershipProvider(Session);
DalCfg.getSchemaExport().Drop(true, true);
DalCfg.getSchemaExport().Create(true, true);
}
internal BasicAuthenticationManager(BasicAuthenticationCredentialsExtractor basicAuthenticationCredentialsExtractor,
AuthorizationStringExtractor httpRequestAuthorizationExtractor,
MembershipProvider membershipProvider,
ResponseMessageFactory responseMessageFactory,
ServiceSecurityContextFactory serviceSecurityContextFactory)
{
this.basicAuthenticationCredentialsExtractor = basicAuthenticationCredentialsExtractor;
this.httpRequestAuthorizationExtractor = httpRequestAuthorizationExtractor;
this.membershipProvider = membershipProvider;
this.responseMessageFactory = responseMessageFactory;
this.serviceSecurityContextFactory = serviceSecurityContextFactory;
}
public void RestorePasswordShouldReturnsNewPassword(FakeMembershipUser user, MembershipProvider membershipProvider, AccountRepository repo)
{
user.ProviderName.Returns("fake");
membershipProvider.ResetPassword(Arg.Any<string>(), Arg.Any<string>()).Returns("new password");
membershipProvider.Name.Returns("fake");
membershipProvider.GetUser(Arg.Any<string>(), Arg.Any<bool>()).Returns(user);
using (new MembershipSwitcher(membershipProvider))
{
repo.RestorePassword(@"extranet\John").Should().Be("new password");
}
}
public void Init()
{
try
{
mp = Membership.Providers[ProviderName];
CreateSpecialUser();
}
catch(Exception ex)
{
Console.WriteLine(ex.Message + Environment.NewLine + ex.StackTrace);
}
}
public ProviderInitializationHttpModule(MembershipProvider membershipProvider, RoleProvider roleProvider)
{
MembershipCreateStatus createStatus;
Roles.CreateRole("Administrator");
string username = ConfigurationManager.AppSettings["default:username"];
string password = ConfigurationManager.AppSettings["default:password"];
string email = ConfigurationManager.AppSettings["default:email"];
Membership.CreateUser(username, password, email, null, null, true, null, out createStatus);
Roles.AddUserToRole("admin", "Administrator");
}
/// <summary>
/// Initializes a new instance of the <see cref="PhunSimpleMembershipProvider"/> class.
/// </summary>
/// <param name="previousProvider">The previous provider.</param>
public PhunSimpleMembershipProvider(MembershipProvider previousProvider)
{
this._previousProvider = previousProvider;
if (this._previousProvider != null)
{
this._previousProvider.ValidatingPassword += (sender, args) =>
{
if (!this.InitializeCalled)
{
this.OnValidatingPassword(args);
}
};
}
}
public override void PostInitializeUpdate(MembershipProvider provider)
{
var connectionStringProperty = GetConnectionStringProperty();
var connectionStringSettings = new ConnectionStringSettings()
{
ProviderName = "System.Data.SqlClient",
ConnectionString = "MultipleActiveResultSets=True;" + DatabaseInitialization.GetConnectionStringFor(FixtureConstants.UniversalMembershipProviderDatabaseName)
};
connectionStringProperty.SetValue(provider, connectionStringSettings, null);
base.PostInitializeUpdate(provider);
}
public AspNetMembershipProviderSettingsWrapper(MembershipProvider provider)
: this(new RegistrationSettings(provider.RequiresUniqueEmail),
new PasswordSettings(
new PasswordResetRetrievalSettings(provider.EnablePasswordReset,
provider.EnablePasswordRetrieval,
provider.RequiresQuestionAndAnswer),
provider.MinRequiredPasswordLength,
provider.MinRequiredNonAlphanumericCharacters,
provider.PasswordStrengthRegularExpression,
provider.PasswordFormat),
new LoginSettings(provider.MaxInvalidPasswordAttempts,
provider.PasswordAttemptWindow))
{
}
///<summary>
///Initializes the provider.
///</summary>
///
///<param name="config">A collection of the name/value pairs representing the provider-specific
/// attributes specified in the configuration for this provider.
/// The <c>providerId</c> attribute may be used to override the name being used for looking up an object definition.
/// </param>
///<param name="name">The friendly name of the provider.</param>
///<exception cref="T:System.ArgumentNullException">The <paramref name="name"/> or <paramref name="config"/> is null.</exception>
///<exception cref="T:System.InvalidOperationException">An attempt is made to call <see cref="M:System.Configuration.Provider.ProviderBase.Initialize(System.String,System.Collections.Specialized.NameValueCollection)"></see> on a provider after the provider has already been initialized.</exception>
///<exception cref="T:System.ArgumentException">The <paramref name="name"/> has a length of zero or providerId attribute is not set.</exception>
public override void Initialize(string name, NameValueCollection config)
{
lock (this)
{
if (config == null) throw new ArgumentNullException("config");
string providerId = config["providerId"];
if (String.IsNullOrEmpty(providerId))
providerId = name;
config.Remove("providerId");
this.wrappedProvider = (MembershipProvider) WebApplicationContext.GetRootContext().GetObject(providerId);
this.wrappedProvider.Initialize(name, config);
}
}
/// <summary>
/// Sets up.
/// </summary>
public override void SetUp()
{
base.SetUp();
this.provider = new UsersMembershipProvider();
var config = new NameValueCollection
{
{ "name", "UsersMembershipProvider" },
{ "enablePasswordRetrieval", "false" },
{ "enablePasswordReset", "false" },
{ "requiresQuestionAndAnswer", "false" },
{ "passwordFormat", "Hashed" }
};
this.provider.Initialize(config["name"], config);
}
public void Exists_UserExists_ShouldReturnTrue(FakeMembershipUser user, MembershipProvider membershipProvider, AccountRepository repo)
{
membershipProvider.GetUser(@"somedomain\John", Arg.Any<bool>()).Returns(user);
var context = new FakeSiteContext(new StringDictionary
{
{"domain", "somedomain"}
});
using (new Switcher<Domain, Domain>(new Domain("somedomain")))
{
using (new MembershipSwitcher(membershipProvider))
{
var exists = repo.Exists("John");
exists.Should().BeTrue();
}
}
}
/// <summary>
///
/// </summary>
static Common()
{
/* ensure assemblies are loaded
* this loads assemblies that may not be loaded because they have not direct reference
* but need to be loaded because they may contain modules and portlets
*/
EnsureAssembliesAreLoaded();
_cacheManager = new CacheManager();
// providers
_databaseProvider = Databases.Provider as PortalDatabaseProvider;
_pathProvider = CommunityPaths.Provider;
_configurationProvider = CommunityConfigurations.Provider;
_membershipProvider = global::System.Web.Security.Membership.Provider;
_roleProvider = global::System.Web.Security.Roles.Provider;
}
private bool ValidateLogOnInformation(MembershipProvider membershipProvider, string userName, string password)
{
if (String.IsNullOrEmpty(userName))
{
ModelState.AddModelError("username", "You must specify a username.");
}
if (String.IsNullOrEmpty(password))
{
ModelState.AddModelError("password", "You must specify a password.");
}
if (!membershipProvider.ValidateUser(userName, password))
{
ModelState.AddModelError("_FORM", "The username or password provided is incorrect.");
}
return ModelState.IsValid;
}
public void Setup()
{
RavenDb.InitializeStorage();
((RavenDbStorage) RavenDb.Storage).SessionSettings.SetStaleResultsWhait(StaleResultWhaitMode.AllNonStale);
var repositoryFactory = Substitute.For<IRepositoryFactory>();
repositoryFactory.CreateUserRepository().Returns(_ => _enableOutsideSession
? new UserRepositoryImpl(_outsideSession)
: new UserRepositoryImpl(RavenDb.Storage));
repositoryFactory.CreateRoleRepository().Returns(_ => _enableOutsideSession
? new RoleRepositoryImpl(_outsideSession)
: new RoleRepositoryImpl(RavenDb.Storage));
RepositoryFactory.Initialize(repositoryFactory);
_roleProvider = new RoleProvider();
_membershipProvider = new MembershipProvider();
}
internal bool ValidateUniqueEmail(MemberSave contentItem, MembershipProvider membershipProvider, HttpActionContext actionContext)
{
if (contentItem == null) throw new ArgumentNullException("contentItem");
if (membershipProvider == null) throw new ArgumentNullException("membershipProvider");
if (membershipProvider.RequiresUniqueEmail == false)
{
return true;
}
int totalRecs;
var existingByEmail = membershipProvider.FindUsersByEmail(contentItem.Email.Trim(), 0, int.MaxValue, out totalRecs);
switch (contentItem.Action)
{
case ContentSaveAction.Save:
//ok, we're updating the member, we need to check if they are changing their email and if so, does it exist already ?
if (contentItem.PersistedContent.Email.InvariantEquals(contentItem.Email.Trim()) == false)
{
//they are changing their email
if (existingByEmail.Cast<MembershipUser>().Select(x => x.Email)
.Any(x => x.InvariantEquals(contentItem.Email.Trim())))
{
//the user cannot use this email
return false;
}
}
break;
case ContentSaveAction.SaveNew:
//check if the user's email already exists
if (existingByEmail.Cast<MembershipUser>().Select(x => x.Email)
.Any(x => x.InvariantEquals(contentItem.Email.Trim())))
{
//the user cannot use this email
return false;
}
break;
default:
//we don't support this for members
throw new HttpResponseException(HttpStatusCode.NotFound);
}
return true;
}
public static System.Web.Security.MembershipUser CreateUser(this System.Web.Security.MembershipProvider pProvider, String pUserName, String pPassword, String pPostalAddress, String pEmail, string passwordQuestion, string passwordAnswer, bool isApproved, object providerUserKey, out System.Web.Security.MembershipCreateStatus status)
{
try
{
User lUser = new User()
{
Address = pPostalAddress, Name = pUserName, LoginCredential = new LoginCredential()
{
UserName = pUserName, Password = pPassword
}, Email = pEmail
};
MembershipProvider.CreateUser(lUser);
status = MembershipCreateStatus.Success;
}
catch (Exception)
{
status = MembershipCreateStatus.ProviderError;
}
return(new MembershipUser("VideoStoreMembershipProvider", pUserName, null, pEmail, null, null, true, false, DateTime.Now, DateTime.Now, DateTime.Now, DateTime.Now, DateTime.MinValue));
}
private static SimpleMembershipProvider CreateDefaultSimpleMembershipProvider(string name, System.Web.Security.MembershipProvider currentDefault)
{
var membership = new SimpleMembershipProvider(previousProvider: currentDefault);
NameValueCollection config = new NameValueCollection();
membership.Initialize(name, config);
return(membership);
}
public AccountMembershipService(System.Web.Security.MembershipProvider provider)
{
_provider = provider ?? Membership.Provider;
}
private MembershipProvider()
{
_Provider = Membership.Providers["SqlMembershipProvider"];
}
protected void SaveButton_Click(object sender, EventArgs e)
{
Errors.Items.Clear();
string serverType = ServerTypeDrop.SelectedValue;
DbServer serverTypeParsed;
if (!Enum.TryParse <DbServer>(serverType, out serverTypeParsed))
{
Errors.Items.Add("Please, choose the type of database engine you wish to use.");
return;
}
// initial testing of the database connection before we attempt to create the main schema
IBaseDriver drv = null;
switch (serverTypeParsed)
{
case DbServer.MySql:
drv = new BaseDriverMySql(SystemConnstringTextBox.Text);
break;
case DbServer.MsSql:
drv = new BaseDriverMsSql(SystemConnstringTextBox.Text);
break;
}
try
{
drv.TestConnection();
drv.TestDatabaseIsEmpty();
}
catch (Exception ex)
{
Errors.Items.Add(ex.Message);
return;
}
if (UsernameTextBox.Text == "")
{
Errors.Items.Add("Please, insert the initial user's name");
return;
}
if (PasswordTextBox.Text.Length < 7)
{
Errors.Items.Add("The password must be at least 7 characters long.");
return;
}
if (PasswordTextBox.Text != RetypePasswordTextBox.Text)
{
Errors.Items.Add("The passwords do not match.");
return;
}
try
{
System.Net.Mail.MailAddress address = new System.Net.Mail.MailAddress(MailTextBox.Text);
}
catch (FormatException fe)
{
Errors.Items.Add(fe.Message);
return;
}
// run the schema dump script
switch (serverTypeParsed)
{
case DbServer.MySql:
MySql.Data.MySqlClient.MySqlConnection connection = new MySql.Data.MySqlClient.MySqlConnection(SystemConnstringTextBox.Text);
try
{
MySql.Data.MySqlClient.MySqlScript script = new MySql.Data.MySqlClient.MySqlScript(connection);
string scriptText = File.ReadAllText(HttpContext.Current.Server.MapPath(CC.MYSQL_SCHEMA_FILE_PATH));
script.Query = scriptText;
script.Query = scriptText;
connection.Open();
script.Execute();
connection.Clone();
}
catch (Exception esql1)
{
Errors.Items.Add(esql1.Message);
connection.Close();
return;
}
break;
case DbServer.MsSql:
SqlConnection conn = new SqlConnection(SystemConnstringTextBox.Text);
try
{
string query = File.ReadAllText(HttpContext.Current.Server.MapPath(CC.MSSQL_SCHEMA_FILE_PATH));
Microsoft.SqlServer.Management.Smo.Server sqlServer = new Server(new ServerConnection(conn));
conn.Open();
sqlServer.ConnectionContext.ExecuteNonQuery(query);
conn.Close();
SqlMembershipProvider mssqlProvider = new SqlMembershipProvider();
}
catch (Exception esql2)
{
Errors.Items.Add(esql2.Message);
conn.Close();
return;
}
break;
}
var configuration = System.Web.Configuration.WebConfigurationManager.OpenWebConfiguration("~");
var section = (ConnectionStringsSection)configuration.GetSection("connectionStrings");
System.Web.Security.MembershipProvider membership = null;
string username = UsernameTextBox.Text;
string password = PasswordTextBox.Text;
string mail = MailTextBox.Text;
MembershipCreateStatus status;
// rewrite the connection in the database and reload the connstring section, also set the defaultProvidder for the membership tag
switch (serverTypeParsed)
{
case DbServer.MySql:
section.ConnectionStrings["MySqlServer"].ConnectionString = SystemConnstringTextBox.Text;
configuration.AppSettings.Settings["ServerType"].Value = "MySql";
configuration.Save();
SetDefaultMembershipProvider("MySqlMembershipProvider");
// remove the readonly attribute of the connection string variable of the connfiguration
var settingsMy = ConfigurationManager.ConnectionStrings["MsSqlServer"];
var fiMy = typeof(ConfigurationElement).GetField("_bReadOnly", BindingFlags.Instance | BindingFlags.NonPublic);
fiMy.SetValue(settingsMy, false);
settingsMy.ConnectionString = SystemConnstringTextBox.Text;
membership = Membership.Providers["MySqlMembershipProvider"];
membership.CreateUser(username, password, mail, "Dummy question", "Dummy answer", true, 1, out status);
break;
case DbServer.MsSql:
section.ConnectionStrings["MsSqlServer"].ConnectionString = SystemConnstringTextBox.Text;
configuration.AppSettings.Settings["ServerType"].Value = "MsSql";
configuration.Save();
SetDefaultMembershipProvider("MsSqlMembershipProvider");
// remove the readonly attribute of the connection string variable of the connfiguration
var settings = ConfigurationManager.ConnectionStrings["MsSqlServer"];
var fi = typeof(ConfigurationElement).GetField("_bReadOnly", BindingFlags.Instance | BindingFlags.NonPublic);
fi.SetValue(settings, false);
settings.ConnectionString = SystemConnstringTextBox.Text;
membership = Membership.Providers["MsSqlMembershipProvider"];
// generate a ProviderUserKey
Random rand = new Random();
Guid key = new Guid(rand.Next(), 2, 3, new byte[] { 10, 20, 30, 40, 50, 60, 70, 80 });
((SqlMembershipProvider)membership).CreateUser(username, password, mail, "Dummy question", "Dummy answer", true, key, out status);
break;
}
int totalUsers;
MembershipUser user = membership.FindUsersByName(username, 0, 1, out totalUsers)[username];
SystemDriver sysDriver = new SystemDriver(drv);
sysDriver.SetUserRights((user.ProviderUserKey), null, 11110);
// Set FirstRun to false. This cannot be done by the first configuration object - it wil
// not like the configuration file since it has been modified by SetDefaultMembershipProvider
// in the meantime.
var config2 = System.Web.Configuration.WebConfigurationManager.OpenWebConfiguration("~");
config2.AppSettings.Settings["FirstRun"].Value = "False";
System.Web.Configuration.WebConfigurationManager.AppSettings["FirstRun"] = "False";
config2.Save();
Errors.Items.Add("Done.");
Response.RedirectToRoute("DefaultRoute");
}
public AccountController(IKcsarContext db, IFormsAuthentication formsAuth, System.Web.Security.MembershipProvider provider)
: base(db)
{
Provider = provider;
FormsAuth = formsAuth;
}
