private static bool Configure(string connectionId, Func <DatabaseConnectionConfiguration, bool> validateConfigFunc)
{
var configurationIsOk = false;
try
{
using (var dialog = new DataConnectionDialog())
{
dialog.ChooseDataSourceTitle = $"Database connection: {connectionId}";
dialog.Title = $"Database connection: {connectionId}";
// If you want the user to select from any of the available data sources, do this:
DataSource.AddStandardDataSources(dialog);
// OR, if you want only certain data sources to be available
// (e.g. only SQL Server), do something like this instead:
//dialog.DataSources.Add(DataSource.SqlDataSource);
//dialog.DataSources.Add(DataSource.SqlFileDataSource);
while (!configurationIsOk)
{
// The way how you show the dialog is somewhat unorthodox; `dialog.ShowDialog()`
// would throw a `NotSupportedException`. Do it this way instead:
DialogResult userChoice = DataConnectionDialog.Show(dialog);
// Return the resulting connection string if a connection was selected:
if (userChoice == DialogResult.OK)
{
var config = new DatabaseConnectionConfiguration();
config.ConnectionString = dialog.ConnectionString;
config.ConnectionId = connectionId;
if (dialog.SelectedDataSource.Name.Contains("Oracle"))
{
config.DatabaseType = EDatabaseType.Oracle;
}
else
{
config.DatabaseType = EDatabaseType.MSSQLServer;
}
DatabaseConnectionManager.SaveConfiguration(config);
configurationIsOk = validateConfigFunc(config);
}
else
{
configurationIsOk = false;
}
}
}
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
return(configurationIsOk);
}
public override bool CheckConnectionForDataContext(Type dbContextType, DatabaseConnectionConfiguration connectionConfiguration)
{
var context = GetDataContextOfType(dbContextType, connectionConfiguration) as DbContext;
context.Database.OpenConnection();
context.Database.CloseConnection();
return(true);
}
private Func <TDataContext> CreateDataContextConstructor <TDataContext>(DatabaseConnectionConfiguration connectionConfig) where TDataContext : DbContext
{
return(() =>
{
var optionsBuilder = GetDbContextOptionsBuilder <TDataContext>(connectionConfig);
return Activator.CreateInstance(typeof(TDataContext), optionsBuilder.Options) as TDataContext;
});
}
public string Create(DatabaseConnectionConfiguration configuration)
{
var builder = new SqliteConnectionStringBuilder
{
DataSource = $"{configuration.Database}.db"
};
return(builder.ConnectionString);
}
public static bool Configure(DatabaseConnectionConfiguration configuration)
{
try
{
using (var dialog = new DataConnectionDialog())
{
dialog.ChooseDataSourceTitle = $"Database connection: {configuration.ConnectionId}";
dialog.Title = $"Database connection: {configuration.ConnectionId}";
DataSource.AddStandardDataSources(dialog);
if (!string.IsNullOrEmpty(configuration.ConnectionString))
{
if (configuration.DatabaseType == EDatabaseType.MSSQLServer)
{
dialog.SelectedDataSource = DataSource.SqlDataSource;
}
else
{
dialog.SelectedDataSource = DataSource.OracleDataSource;
}
dialog.ConnectionString = configuration.ConnectionString;
}
DialogResult userChoice = DataConnectionDialog.Show(dialog);
// Return the resulting connection string if a connection was selected:
if (userChoice == DialogResult.OK)
{
configuration.ConnectionString = dialog.ConnectionString;
if (dialog.SelectedDataSource.Name.Contains("Oracle"))
{
configuration.DatabaseType = EDatabaseType.Oracle;
}
else
{
configuration.DatabaseType = EDatabaseType.MSSQLServer;
}
DatabaseConnectionManager.SaveConfiguration(configuration);
return(true);
}
}
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
return(false);
}
private Func <TDataContext> GetDataContextConstructor <TDataContext>(DatabaseConnectionConfiguration connectionConfig) where TDataContext : DbContext
{
if (_dataContextConstructors.ContainsKey(typeof(TDataContext)))
{
return((Func <TDataContext>)_dataContextConstructors[typeof(TDataContext)]);
}
else
{
return(CreateDataContextConstructor <TDataContext>(connectionConfig));
}
}
private static IDatabaseConnectionConfiguration CreateDatabaseConnectionConfiguration(IComponentContext context)
{
var configuration = context.Resolve <IConfiguration>();
var result = new DatabaseConnectionConfiguration();
new ConfigureFromConfigurationOptions <DatabaseConnectionConfiguration>(configuration.GetSection("Data"))
.Configure(result);
return(result);
}
public override object GetDataContextOfType(Type dataContextType, DatabaseConnectionConfiguration connectionConfiguration)
{
// Get the generic method `Foo`
var fooMethod = typeof(EFCoreDataContextHandler).GetMethod(nameof(GetDataContextConstructor), BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
// Make the non-generic method via the `MakeGenericMethod` reflection call.
// Yes - this is confusing Microsoft!!
var fooOfBarMethod = fooMethod.MakeGenericMethod(dataContextType);
// Invoke the method just like a normal method.
var contructorFunc = fooOfBarMethod.Invoke(this, new[] { connectionConfiguration }) as Func <DbContext>;
//return GetDataContextConstructor(dataContextType)();
return(contructorFunc());
}
private DbConnection GetConnection(DatabaseConnectionConfiguration config)
{
if (config.DatabaseType == EDatabaseType.MSSQLServer)
{
return(GetSqlServerConnection(config));
}
else if (config.DatabaseType == EDatabaseType.Oracle)
{
return(GetOracleConnection(config));
}
else
{
throw new DatabaseConnectionException($"Connections with database type {config.DatabaseType} are not supported yet.");
}
}
private Func <TDataContext> GetDataContextConstructor <TDataContext>(DatabaseConnectionConfiguration connectionConfig) where TDataContext : DbContext
{
if (_dataContextConstructors.ContainsKey(typeof(TDataContext)))
{
return((Func <TDataContext>)_dataContextConstructors[typeof(TDataContext)]);
}
else
{
return(() =>
{
//var config = DatabaseConnectionManager.GetConfiguration(typeof(TDataContext).Name);
//var config = DatabaseConnectionManager.GetConfiguration(configName);
var conn = GetConnection(connectionConfig);
return Activator.CreateInstance(typeof(TDataContext), conn) as TDataContext;
});
}
}
public string Create(DatabaseConnectionConfiguration configuration)
{
var timeoutInSeconds = (uint)TimeSpan.FromMilliseconds(configuration.TimeoutInMilliseconds).TotalSeconds;
var builder = new MySqlConnectionStringBuilder
{
Server = configuration.Host,
Port = configuration.Port,
UserID = configuration.User,
Password = configuration.Password,
Database = configuration.Database,
ConnectionTimeout = timeoutInSeconds,
DefaultCommandTimeout = timeoutInSeconds,
ConvertZeroDateTime = true,
CharacterSet = "utf8"
};
return(builder.ConnectionString);
}
public TaskRepository(DatabaseConnectionConfiguration databaseConnectionConfiguration) : base(databaseConnectionConfiguration)
{
}
public void Configure(DbContextOptionsBuilder dbContextOptionsBuilder, DatabaseConnectionConfiguration configuration)
{
var connectionString = _connectionStringFactory.Create(configuration);
dbContextOptionsBuilder.UseSqlite(connectionString);
}
private void ConfigureForMSSQLServer <TDataContext>(DatabaseConnectionConfiguration config, DbContextOptionsBuilder <TDataContext> dbContextOptionsBuilder) where TDataContext : DbContext
{
dbContextOptionsBuilder.UseSqlServer(config.ConnectionString);
}
private void ConfigureForInMemoryTempDB <TDataContext>(DatabaseConnectionConfiguration config, DbContextOptionsBuilder <TDataContext> dbContextOptionsBuilder) where TDataContext : DbContext
{
dbContextOptionsBuilder.UseInMemoryDatabase(config.ConnectionString);
}
public void Configure(DbContextOptionsBuilder dbContextOptionsBuilder, DatabaseConnectionConfiguration configuration)
{
var connectionString = _connectionStringFactory.Create(configuration);
dbContextOptionsBuilder.UseMySql(connectionString, ServerVersion.AutoDetect(connectionString));
}
public abstract bool CheckConnectionForDataContext(Type dbContextType, DatabaseConnectionConfiguration connectionConfiguration);
public static bool CheckDatabaseConnection(string connectionId, Func <DatabaseConnectionConfiguration, bool> validateConfigFunc, bool allowConfiguration, bool forceConfiguration = false)
{
LoggerService.LogDebugAsync("CheckRegisteredDatabasesConnections", () => new { allowConfiguration, forceConfiguration, connectionId }).Wait();
if ((allowConfiguration || forceConfiguration) && DatabaseConnectionConfigurator == null)
{
var logmessage = "DatabaseConnectionConfigurator is null";
LoggerService.LogAsync(logmessage, ELogType.Error, new { allowConfiguration, forceConfiguration, connectionId }).Wait();
throw new InvalidOperationException(logmessage);
}
var connectionSucceeded = false;
DatabaseConnectionConfiguration config = null;
try
{
config = DatabaseConnectionManager.GetConfiguration(connectionId);
}
catch (DatabaseConnectionException)
{
config = new DatabaseConnectionConfiguration()
{
ConnectionId = connectionId
};
}
//do
{
try
{
// Try the first time without configuring
if (forceConfiguration || !Validate())
{
// If it fails, try to configure, and then check again
if ((allowConfiguration || forceConfiguration) && DatabaseConnectionConfigurator.Configure(ref config))
{
DatabaseConnectionManager.SaveConfiguration(config);
connectionSucceeded = Validate();
}
}
else
{
connectionSucceeded = true;
}
}
catch (Exception ex)
{
LoggerService.LogAsync(ex).Wait();
}
} //while (!connectionSucceeded && allowConfiguration);
return(connectionSucceeded);
bool Validate()
{
try
{
return(validateConfigFunc(config));
}
catch (Exception dbe)
{
LoggerService.Log(dbe);
return(false);
}
}
}
public ConfigureServerController(CustomSettings customSettings, UserManager <ApplicationUser> userManager, RoleManager <ApplicationRole> roleManager, DatabaseConnectionConfiguration databaseConnectionConfiguration)
{
sqlConnectionString = databaseConnectionConfiguration.SqlConnectionString;
Helper.OnConnectionStringAcctualization += (sender, connectionString) =>
{
sqlConnectionString = connectionString;
};
_customSettings = customSettings;
_userManager = userManager;
_roleManager = roleManager;
}
private DbConnection GetSqlServerConnection(DatabaseConnectionConfiguration config)
{
return(new System.Data.Entity.Infrastructure.SqlConnectionFactory().CreateConnection(config.ConnectionString));
}
private DbConnection GetOracleConnection(DatabaseConnectionConfiguration config)
{
return(new Oracle.ManagedDataAccess.EntityFramework.OracleConnectionFactory().CreateConnection(config.ConnectionString));
}
public ApplicationUserRepository(DatabaseConnectionConfiguration databaseConnectionConfiguration) : base(databaseConnectionConfiguration)
{
}
private DbContextOptionsBuilder <TDataContext> GetDbContextOptionsBuilder <TDataContext>(DatabaseConnectionConfiguration connectionConfig) where TDataContext : DbContext
{
var dbOptions = new DbContextOptionsBuilder <TDataContext>();
if (connectionConfig.DatabaseType == EDatabaseType.MSSQLServer)
{
ConfigureForMSSQLServer(connectionConfig, dbOptions);
}
else if (connectionConfig.DatabaseType == EDatabaseType.SQLite)
{
ConfigureForSQLite(connectionConfig, dbOptions);
}
else if (connectionConfig.DatabaseType == EDatabaseType.InMemoryTempDB)
{
ConfigureForInMemoryTempDB(connectionConfig, dbOptions);
}
else
{
throw new DatabaseConnectionException($"Connections with database type {connectionConfig.DatabaseType} are not supported yet.");
}
return(dbOptions);
}
public abstract object GetDataContextOfType(Type dataContextType, DatabaseConnectionConfiguration connectionConfiguration);
public ApplicationEmployeeRepository(DatabaseConnectionConfiguration databaseConnectionConfiguration) : base(databaseConnectionConfiguration)
{
}
