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) { }