public static async void StartDbBackupOperationAsync(DatabaseConnectionInfo dbConnection, string filename = null)
{
try
{
while (true)
{
try
{
await CreateBackupAsync(dbConnection, filename).ConfigureAwait(false);
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
finally
{
await Task.Delay(TimeSpan.FromHours(24)).ConfigureAwait(false);
}
}
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
public Dictionary <string, DbStoredProc> GetStoredProcedures(DatabaseConnectionInfo connectionInfo)
{
var sql = @"select SCHEMA_NAME(p.schema_id) + '.' + p.name as fullname,p.name ,SCHEMA_NAME(p.schema_id) as schemaName, m.definition from sys.procedures p inner join
sys.sql_modules m on p.object_id = m.object_id";
var procedures = new Dictionary <string, DbStoredProc>();
using (var conn = new SqlConnection(connectionInfo.ConnectionString))
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = sql;
var reader = cmd.ExecuteReader();
var fullNamePos = reader.GetOrdinal("fullName");
var namePos = reader.GetOrdinal("name");
var schemaNamePos = reader.GetOrdinal("schemaName");
var definitionPos = reader.GetOrdinal("definition");
while (reader.Read())
{
procedures.Add(reader.GetString(fullNamePos), new DbStoredProc()
{
Name = reader.GetString(namePos),
SchemaName = reader.GetString(schemaNamePos),
Definition = reader.GetString(definitionPos).Trim()
});
}
}
}
return(procedures);
}
public DbSchema GetSchema(DatabaseConnectionInfo connectionInfo)
{
var dbObjects = new List <DbSchemaObject>();
var tables = GetTables(connectionInfo);
foreach (var dbObject in tables.Values)
{
dbObjects.Add(dbObject);
}
var modules = GetModules(connectionInfo);
foreach (var dbObject in modules)
{
dbObjects.Add(dbObject);
}
var fkeys = GetForeignKeys(connectionInfo);
foreach (var dbObject in fkeys)
{
dbObjects.Add(dbObject);
}
var schema = new DbSchema(dbObjects);
return(schema);
}
public Dictionary <string, DbView> GetViews(DatabaseConnectionInfo connectionInfo)
{
var views = new Dictionary <string, DbView>();
string sql = @"select SCHEMA_NAME(o.schema_id) + '.' + o.name as fullname,
SCHEMA_NAME(o.schema_id) as schemaName, o.name, m.definition
from sys.objects o
join sys.sql_modules m on m.object_id = o.object_id
and o.type= 'V'";
using (var conn = new SqlConnection(connectionInfo.ConnectionString))
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = sql;
var reader = cmd.ExecuteReader();
var fullNamePos = reader.GetOrdinal("fullName");
var namePos = reader.GetOrdinal("name");
var schemaNamePos = reader.GetOrdinal("schemaName");
var definitionPos = reader.GetOrdinal("definition");
while (reader.Read())
{
views.Add(reader.GetString(fullNamePos), new DbView
{
Name = reader.GetString(namePos),
SchemaName = reader.GetString(schemaNamePos),
Definition = reader.GetString(definitionPos).Trim()
});
}
}
}
return(views);
}
protected override void ExecuteCore(string[] arguments)
{
var listCommandOptions = Options;
if (Parser.Default.ParseArguments(arguments, listCommandOptions))
{
Output.Info("soothsayer {0}-beta".FormatWith(Assembly.GetExecutingAssembly().GetName().Version));
Output.EmptyLine();
string password = GetOraclePassword(listCommandOptions);
var databaseConnectionInfo = new DatabaseConnectionInfo(listCommandOptions.ConnectionString, listCommandOptions.Username, password);
using (var connection = _connectionFactory.Create(databaseConnectionInfo))
{
var oracleVersionRepository = _versionRespositoryFactory.Create(connection);
var versions = (oracleVersionRepository.GetAllVersions(listCommandOptions.Schema) ?? Enumerable.Empty <DatabaseVersion>()).ToArray();
if (versions.Any())
{
Output.Info("Found the following versions in schema '{0}' (ascending order)".FormatWith(listCommandOptions.Schema));
Output.EmptyLine();
foreach (var version in versions)
{
Output.Text(" {0}\t\t{1}".FormatWith(version.Version, version.ScriptName));
}
Output.EmptyLine();
}
}
}
}
public static void InitializeDatabaseConnection(string connectionStringName, string userTableName, string userIdColumn, string userNameColumn, bool autoCreateTables)
{
DatabaseConnectionInfo connect = new DatabaseConnectionInfo();
connect.ConnectionStringName = connectionStringName;
InitializeProviders(connect, userTableName, userIdColumn, userNameColumn, autoCreateTables);
}
Initialize_SettingsContainServerConnectStringForDataProvider_InitializesAccordingToServerConnectString()
{
var dataProviderInfo = new MySqlInfo();
const string serverConnectStringFoundInSettings =
"data source = servername; user id = username; password = pass;";
var settingsMock = new Mock <IDatabaseSettings>();
settingsMock
.Setup(ds => ds.ProviderIsAvailable(dataProviderInfo))
.Returns(true);
settingsMock
.Setup(ds => ds.GetServerConnectStringFor(dataProviderInfo))
.Returns(serverConnectStringFoundInSettings);
_container
.RegisterInstance(settingsMock.Object);
var sut = _container
.Resolve <ConfigureDataProviderViewModelMock>();
sut.DataProviderInfoMock = dataProviderInfo;
sut.Initialize();
string actualServerConnectString =
new DatabaseConnectionInfo(sut.ServerName, sut.UserName, sut.Password).ServerConnectString;
Assert.That(actualServerConnectString, Is.EqualTo(serverConnectStringFoundInSettings));
}
public Dictionary <string, DbTable> GetTables(DatabaseConnectionInfo connectionInfo)
{
var tables = new Dictionary <string, DbTable>();
var sql = @"select sc.Name + '.'+ so.name as fullName, so.name, sc.name as schemaName from sys.objects so
inner join sys.schemas sc on so.schema_id = sc.schema_id
where type in ('U')";
using (var conn = new SqlConnection(connectionInfo.ConnectionString))
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = sql;
var reader = cmd.ExecuteReader();
var fullNamePos = reader.GetOrdinal("fullName");
var namePos = reader.GetOrdinal("name");
var schemaNamePos = reader.GetOrdinal("schemaName");
while (reader.Read())
{
tables.Add(reader.GetString(fullNamePos), new DbTable
{
Name = reader.GetString(namePos),
SchemaName = reader.GetString(schemaNamePos)
});
}
}
}
return(tables);
}
IEnumerator GetDatabaseConnectionInfo()
{
isGetDatabaseConnectionInfoRunning = true;
databaseBaseURL = "http://127.0.0.1";
databaseBaseURLPort = 3000;
WWW connection = new WWW(Application.absoluteURL + "/database/getConnectionInfo");
yield return(connection);
if (connection.error == null)
{
DatabaseConnectionInfo dbConnectionInfo = DatabaseConnectionInfo.CreateFromJSON(connection.text);
Debug.Log(string.Format("DB Connection Info: {0}:{1}", dbConnectionInfo.connectionURL, dbConnectionInfo.connectionPort));
databaseBaseURL = dbConnectionInfo.connectionURL;
databaseBaseURLPort = dbConnectionInfo.connectionPort;
}
else
{
Debug.LogError("Error: " + connection.error + "\n Could not get Database Connection Information. Using localhost:3000.");
}
databaseURL = string.Format("{0}:{1}", databaseBaseURL, databaseBaseURLPort);
isGetDatabaseConnectionInfoRunning = false;
Debug.LogWarning("Using the following Database Address: " + databaseURL);
yield return(null);
}
public SchemaBrowserVM(ISchemaBrowserModel iSchemaBrowserModel, ICodeGenerator iCodeGenerator, DatabaseConnectionInfo databaseConnectionInfo)
{
model = iSchemaBrowserModel;
codeGenerator = iCodeGenerator;
currentDatabase = databaseConnectionInfo;
GeneratCodeCommand = new DelegateCommand <object>(GeneratCode);
}
public Dictionary <string, DbTable> GetTables(DatabaseConnectionInfo connectionInfo)
{
var tables = new Dictionary <string, DbTable>();
var sql = @"SELECT table_name as name FROM information_schema.tables WHERE table_type = 'base table'";
using (var conn = new MySqlConnection(connectionInfo.ConnectionString))
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = sql;
var reader = cmd.ExecuteReader();
var namePos = reader.GetOrdinal("name");
while (reader.Read())
{
tables.Add(reader.GetString(namePos), new DbTable
{
Name = reader.GetString(namePos),
});
}
}
}
return(tables);
}
private List <DbSchemaObject> GetModules(DatabaseConnectionInfo connectionInfo,
SqlCommand getModulesCommand)
{
List <DbSchemaObject> objects = new List <DbSchemaObject>();
using (SqlConnection conn = new SqlConnection(connectionInfo.ConnectionString))
{
conn.Open();
//Get tables
getModulesCommand.Connection = conn;
using (var reader = getModulesCommand.ExecuteReader())
{
var fullNamePos = reader.GetOrdinal("fullName");
var namePos = reader.GetOrdinal("name");
var schemaNamePos = reader.GetOrdinal("schemaName");
var typePos = reader.GetOrdinal("type");
var definitionPos = reader.GetOrdinal("definition");
while (reader.Read())
{
var sqlServerType = reader.GetString(typePos).Trim();
DbSchemaObject dbObject = NewObjectOfType(sqlServerType);
dbObject.Name = reader.GetString(namePos);
dbObject.SchemaName = reader.GetString(schemaNamePos);
dbObject.Definition = reader.GetString(definitionPos).Trim();
objects.Add(dbObject);
}
}
return(objects);
}
}
private async void TestConnection(DatabaseConnectionInfo conn)
{
conn.Status = EConnectivityStatus.Testing;
var result = await testerDict[conn.DatabaseType].TestConnectivityAsync(conn.ConnectionString);
conn.Status = (result) ? EConnectivityStatus.Connected : EConnectivityStatus.Disconnected;
}
public SqlPlusScriptRunner(IProcessRunner processRunner, DatabaseConnectionInfo databaseConnectionInfo)
{
_processRunner = processRunner;
_username = databaseConnectionInfo.Username;
_password = databaseConnectionInfo.Password;
_connectionString = databaseConnectionInfo.ConnectionString;
_sqlPlusConfiguration = new SqlPlusConfiguration();
}
public void Construct_SqliteConnectionStringContainingFilePath_DatabaseIsFileNameWithoutExtension()
{
const string databaseName = "testdatabase";
const string fileName = databaseName + ".db3";
const string fullPath = @"C:\Documents\User\" + fileName;
var sut = new DatabaseConnectionInfo("Data Source = " + fullPath);
Assert.That(sut.Database, Is.EqualTo(databaseName));
}
/// <summary>
/// Construct a valid PostgreSQL Npgsql connection string
/// </summary>
/// <param name="connectionInfo">Information needed to establish a connection with the database</param>
/// <returns>Valid Npgsql connection string</returns>
protected override string ConstructConnectionString(DatabaseConnectionInfo connectionInfo)
{
return(string.Format("Host={0};Port={1};Database={2};Username={3};Password={4}",
connectionInfo.HostName,
connectionInfo.HostPort,
connectionInfo.DatabaseName,
connectionInfo.UserName,
connectionInfo.UserPassword));
}
public SqlPlusScriptRunner(IProcessRunner processRunner, DatabaseConnectionInfo databaseConnectionInfo)
{
_processRunner = processRunner;
_username = databaseConnectionInfo.Username;
_password = databaseConnectionInfo.Password;
_connectionString = databaseConnectionInfo.ConnectionString;
_sqlPlusConfiguration = new SqlPlusConfiguration();
}
private void CreateConnection()
{
var conn = new DatabaseConnectionInfo();
conn.FriendlyName = "New Connection String";
conn.ConnectionString = "Connection string";
conn.Status = EConnectivityStatus.Unknown;
conn.ObjectKey = new Guid();
Connections.Insert(0, conn);
}
private Dictionary <string, DbForeignKey> GetForeignKeys(DatabaseConnectionInfo connectionInfo)
{
var fKeys = new Dictionary <string, DbForeignKey>();
var sql = @"select SCHEMA_NAME(sof.schema_id) + '.' + sof.name as ConstraintName ,
SCHEMA_NAME(sop.schema_id) + '.' + sop.name as ForeignKeyTable,
SCHEMA_NAME(sor.schema_id) + '.' +sor.name as PrimaryKeyTable,
scp.name as ForeignKeyColumn,
scf.name as PrimaryKeyColumn
from sys.foreign_key_columns fk
inner join Sys.objects sop on fk.parent_object_id = sop.object_id
inner join Sys.objects sof on fk.constraint_object_id = sof.object_id
inner join Sys.objects sor on fk.referenced_object_id = sor.object_id
inner join Sys.Columns scp on fk.parent_column_id = scp.column_id and fk.parent_object_id = scp.object_id
inner join Sys.Columns scf on fk.referenced_column_id = scf.column_id and fk.referenced_object_id = scf.object_id";
var primaryKeys = new Dictionary <string, List <string> >();
using (var conn = new SqlConnection(connectionInfo.ConnectionString))
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = sql;
var reader = cmd.ExecuteReader();
var constraintNamePos = reader.GetOrdinal("ConstraintName");
var foreignKeyTablePos = reader.GetOrdinal("ForeignKeyTable");
var primaryKeyTablePos = reader.GetOrdinal("PrimaryKeyTable");
var foreignKeyColumnPos = reader.GetOrdinal("ForeignKeyColumn");
var primaryKeyColumnPos = reader.GetOrdinal("PrimaryKeyColumn");
while (reader.Read())
{
var constraintName = reader.GetString(constraintNamePos);
DbForeignKey fKey;
if (!fKeys.ContainsKey(constraintName))
{
fKey = new DbForeignKey
{
ConstraintFullName = constraintName,
ForeignKeyTable = reader.GetString(foreignKeyTablePos),
PrimaryKeyTable = reader.GetString(primaryKeyTablePos)
};
fKeys.Add(constraintName, fKey);
}
fKeys[constraintName].Columns.Add(new DbForeignKeyColumn
{
PrimaryKeyColumn = reader.GetString(primaryKeyColumnPos),
ForeignKeyColumn = reader.GetString(foreignKeyColumnPos),
});
}
}
}
return(fKeys);
}
public Dictionary <string, DbTable> GetTables(DatabaseConnectionInfo connectionInfo)
{
var getTablesCommand = GetAllTablesCommand();
var getColumnsCommand = GetAllColumnsCommand();
var getPrimaryKeysCommand = GetAllPrimaryKeysCommand();
var getPrimaryKeyColumnsCommand = GetAllPrimaryKeyColumnsCommand();
var tables = GetTables(connectionInfo, getTablesCommand, getColumnsCommand, getPrimaryKeysCommand, getPrimaryKeyColumnsCommand);
return(tables);
}
/// <summary>
/// Create a new database object
/// </summary>
/// <param name="type">Database to create</param>
/// <param name="connectionInfo">Information needed to connect to the database</param>
/// <returns>New database</returns>
public static Database CreateInstance(DatabaseType type, DatabaseConnectionInfo connectionInfo)
{
switch (type)
{
case DatabaseType.PostgreSQL:
return(new PostgreSQLDatabase(connectionInfo));
default:
throw new ArgumentException("Invalid database type.");
}
}
public ConfigureMySqlDataProviderViewModel(
IEventAggregator eventAggregator, IDatabaseSettings databaseSettings, IDatabaseConnector databaseConnector)
: base(eventAggregator, databaseSettings, databaseConnector)
{
_dataProviderInfo = new MySqlInfo();
DetectMySqlAndSetMySqlVersionInfoAccordinly();
_pokerOfficeSettings = GetPokerofficeSettings();
Initialize();
}
private IQueryModel GetQueryModel(DatabaseConnectionInfo connection)
{
switch (connection.DatabaseType)
{
case "Sql Server":
return(new Models.SqlServer.QueryModel());
case "MySQL":
return(new Models.MySql.QueryModel());
}
return(null);
}
private ISchemaBrowserModel GetSchemaBrowserModel(DatabaseConnectionInfo connection)
{
switch (connection.DatabaseType)
{
case "Sql Server":
return(new SchemaBrowserModel());
case "MySQL":
return(new Models.MySql.SchemaBrowserModel());
}
return(null);
}
public static async Task <List <FileInfoVm> > GetBackupsListAsync(DatabaseConnectionInfo dbConnection)
{
try
{
string dbName = dbConnection.Database;
return(await fileStorage.SearchAsync($"{dbName}_backup_{NodeSettings.Configs.Node.Id}").ConfigureAwait(false));
}
catch (Exception ex)
{
Logger.WriteLog(ex);
return(new List <FileInfoVm>());
}
}
public QueryResult Execute(string query, DatabaseConnectionInfo connectionInfo)
{
var result = new QueryResult();
Stopwatch swatch = new Stopwatch();
swatch.Start();
try
{
using (var conn = new SqlConnection(connectionInfo.ConnectionString))
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandText = query;
cmd.CommandType = CommandType.Text;
var reader = cmd.ExecuteReader();
var fieldCount = reader.FieldCount;
DataTable dt = new DataTable();
for (int i = 0; i < fieldCount; i++)
{
var name = reader.GetName(i);
var ft = reader.GetFieldType(i);
dt.Columns.Add(new DataColumn(name, ft));
}
while (reader.Read())
{
var row = dt.NewRow();
for (int i = 0; i < fieldCount; i++)
{
row[i] = reader.GetValue(i);
}
dt.Rows.Add(row);
}
result.DataTable = dt;
foreach (DataColumn column in dt.Columns)
{
Debug.WriteLine(string.Format("var {0}Pos = reader.GetOrdinal(\"{1}\");", Char.ToLowerInvariant(column.ColumnName[0]) + column.ColumnName.Substring(1), column.ColumnName));
}
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
result.QueryTimeSpan = swatch.Elapsed;
swatch.Stop();
return(result);
}
public static async Task <bool> CreateBackupAsync(DatabaseConnectionInfo dbConnection, string filename = null)
{
if (dbConnection == null)
{
throw new ArgumentNullException(nameof(dbConnection));
}
string dbName = dbConnection.Database;
string userName = dbConnection.Username;
string dbHost = dbConnection.Host;
string dbPass = dbConnection.Password;
int dbPort = dbConnection.Port;
if (filename == null)
{
filename = $"{dbName}_backup_{NodeSettings.Configs.Node.Id}_{DateTime.UtcNow.ToString("ddMMyyyy")}";
}
if ((await fileStorage.SearchAsync($"{filename}.bin").ConfigureAwait(false)).Count == 0)
{
string command = $"\"PGPASSWORD={dbPass} pg_dump -U {userName} {dbName} --compress=9 --format=custom --host {dbHost} --port {dbPort}\"";
ProcessStartInfo processStartInfo = new ProcessStartInfo("/bin/bash", $"-c {command}")
{
RedirectStandardOutput = true,
RedirectStandardError = true
};
var process = Process.Start(processStartInfo);
using (var encryptedStream = await Encryptor.EncryptFileAsync(process.StandardOutput.BaseStream, NodeSettings.Configs.Password, $"{filename}.bin").ConfigureAwait(false))
{
process.WaitForExit();
if (process.ExitCode != 0)
{
string message = await process.StandardError.ReadToEndAsync().ConfigureAwait(false);
throw new Exception($"Error creating backup: {message}");
}
var existingFiles = await fileStorage.SearchAsync($"{dbName}_backup_{NodeSettings.Configs.Node.Id}").ConfigureAwait(false);
if (existingFiles.Count > NodeSettings.Configs.MaxDbBackups)
{
var excessFiles = existingFiles.OrderByDescending(opt => opt.Uploaded).TakeLast(existingFiles.Count - NodeSettings.Configs.MaxDbBackups);
foreach (var file in excessFiles)
{
await fileStorage.RemoveAsync(file.FileId).ConfigureAwait(false);
}
}
await fileStorage.UploadAsync(encryptedStream, $"{filename}.bin").ConfigureAwait(false);
}
File.Delete($"{filename}.bin");
}
return(true);
}
public Dictionary <string, List <DbColumn> > GetTableColumns(DatabaseConnectionInfo connectionInfo)
{
var columns = new Dictionary <string, List <DbColumn> >();
var sql = @"SELECT TABLE_NAME as fullTableName , c.COLUMN_NAME as columnName, c.ORDINAL_POSITION as ordinal , c.IS_NULLABLE as is_nullable,
DATA_TYPE as datatype,c.CHARACTER_MAXIMUM_LENGTH as max_length
, c.NUMERIC_PRECISION
FROM INFORMATION_SCHEMA.COLUMNS c
where TABLE_SCHEMA != 'information_schema'
order by TABLE_NAME , ORDINAL_POSITION
";
using (var conn = new MySqlConnection(connectionInfo.ConnectionString))
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandType = CommandType.Text;
cmd.CommandText = sql;
var reader = cmd.ExecuteReader();
var fullTableNamePos = reader.GetOrdinal("fullTableName");
var columnNamePos = reader.GetOrdinal("columnName");
var is_nullablePos = reader.GetOrdinal("is_nullable");
//var is_identityPos = reader.GetOrdinal("is_identity");
var datatypePos = reader.GetOrdinal("datatype");
var max_lengthPos = reader.GetOrdinal("max_length");
while (reader.Read())
{
var fullTableName = reader.GetString(fullTableNamePos);
if (!columns.ContainsKey(fullTableName))
{
columns.Add(fullTableName, new List <DbColumn>());
}
var col = new DbColumn
{
Name = reader.GetString(columnNamePos),
IsNullable = (reader.GetString(is_nullablePos) == "YES"),
//IsIdentity = reader.GetBoolean(is_identityPos),
DataType = reader.GetString(datatypePos),
MaxLength = GetMaxLength(reader.GetValue(max_lengthPos))
};
col.DisplayDataType = DisplayType(col);
columns[fullTableName].Add(col);
}
}
}
return(columns);
}
public DynamicSqlAccess(string xmlRequest)
{
XmlRequestUtility request = new XmlRequestUtility(xmlRequest);
_requestConnection = new DatabaseConnectionInfo()
{
ServerName = request.ServerName,
CatalogName = request.CatalogName,
Password = request.Password,
ServerType = request.ServerType,
UserName = request.UserName
};
ConnectionFactory = () => new SqlConnection(CreateConnStr(_requestConnection));
}
private DatabaseConnectionInfo GetDatabaseConnectionInfo()
{
DatabaseConnectionInfo databaseConnectionInfo = new DatabaseConnectionInfo();
databaseConnectionInfo.Host = txtHost.Text.Trim();
Int32 tmpPort = -1;
Int32.TryParse(txtPort.Text.Trim(), out tmpPort);
databaseConnectionInfo.Port = tmpPort;
databaseConnectionInfo.UserName = txtUserName.Text.Trim();
databaseConnectionInfo.Password = txtPassword.Text.Trim();
return(databaseConnectionInfo);
}
private string CreateConnStr(DatabaseConnectionInfo requestConnection)
{
var builder = new SqlConnectionStringBuilder
{
DataSource = requestConnection.ServerName, // server address
InitialCatalog = requestConnection.CatalogName, // database name
IntegratedSecurity = false, // server auth(false)/win auth(true)
MultipleActiveResultSets = false, // activate/deactivate MARS
PersistSecurityInfo = true, // hide login credentials
UserID = requestConnection.UserName, // user name
Password = requestConnection.Password // password
};
return(builder.ConnectionString);
}
private static void InitializeProviders(DatabaseConnectionInfo connect, string userTableName, string userIdColumn, string userNameColumn, bool autoCreateTables)
{
SimpleMembershipProvider simpleMembership = Membership.Provider as SimpleMembershipProvider;
if (simpleMembership != null) {
InitializeMembershipProvider(simpleMembership, connect, userTableName, userIdColumn, userNameColumn, autoCreateTables);
}
SimpleRoleProvider simpleRoles = Roles.Provider as SimpleRoleProvider;
if (simpleRoles != null) {
InitializeRoleProvider(simpleRoles, connect, userTableName, userIdColumn, userNameColumn, autoCreateTables);
}
Initialized = true;
}
internal static void InitializeRoleProvider(SimpleRoleProvider simpleRoles, DatabaseConnectionInfo connect, string userTableName, string userIdColumn, string userNameColumn, bool createTables)
{
if (simpleRoles.InitializeCalled) {
throw new InvalidOperationException(WebDataResources.Security_InitializeAlreadyCalled);
}
simpleRoles.ConnectionInfo = connect;
simpleRoles.UserTableName = userTableName;
simpleRoles.UserIdColumn = userIdColumn;
simpleRoles.UserNameColumn = userNameColumn;
if (createTables) {
simpleRoles.CreateTablesIfNeeded();
}
simpleRoles.InitializeCalled = true;
}
public static void InitializeDatabaseConnection(string connectionString, string providerName, string userTableName, string userIdColumn, string userNameColumn, bool autoCreateTables)
{
DatabaseConnectionInfo connect = new DatabaseConnectionInfo();
connect.ConnectionString = connectionString;
connect.ProviderName = providerName;
InitializeProviders(connect, userTableName, userIdColumn, userNameColumn, autoCreateTables);
}
internal static void InitializeMembershipProvider(SimpleMembershipProvider simpleMembership, DatabaseConnectionInfo connect, string userTableName, string userIdColumn, string userNameColumn, bool createTables)
{
if (simpleMembership.InitializeCalled) {
throw new InvalidOperationException(WebDataResources.Security_InitializeAlreadyCalled);
}
simpleMembership.ConnectionInfo = connect;
simpleMembership.UserIdColumn = userIdColumn;
simpleMembership.UserNameColumn = userNameColumn;
simpleMembership.UserTableName = userTableName;
if (createTables) {
simpleMembership.CreateTablesIfNeeded();
} else {
// We want to validate the user table if we aren't creating them
simpleMembership.ValidateUserTable();
}
simpleMembership.InitializeCalled = true;
}
public IDbConnection Create(DatabaseConnectionInfo databaseConnectionInfo)
{
return Create(databaseConnectionInfo.ConnectionString, databaseConnectionInfo.Username, databaseConnectionInfo.Password);
}
