public MsSqlCloudFoundryService(IConfiguration configuration, IDatabaseBuilder databaseBuilder) { this.configuration = configuration; this.databaseBuilder = databaseBuilder; Service = new MsSqlService(); Id = Service.Id; }
public void Build(IDatabaseBuilder builder) { //I don't call this because I didn't setup the app.config //builder.BuildConnection(); builder.BuildCommand(); builder.SetSettings(); }
public void ThrowExceptionWhenTryConfigureAfterBuild() { IDatabaseBuilder builder = Database .Builder .UseConnection(ServerHelper.Connection); builder.Build(); IModelFactory modelFactory = Substitute.For <IModelFactory>(); IQueryProviderFactory queryProviderFactory = Substitute.For <IQueryProviderFactory>(); void ShouldThrowException(Action action) { action .Should() .Throw <InvalidOperationException>( "The configuration is not allowed if the Build method has already been called."); } ShouldThrowException(() => builder.UseConnection(ServerHelper.Connection)); ShouldThrowException(() => builder.UseConnection(ServerHelper.Connection.ConnectionString)); ShouldThrowException(() => builder.UseDatabaseConfiguration <DatabaseConfiguration>()); ShouldThrowException(() => builder.UseDatabaseConfiguration(new DatabaseConfiguration())); ShouldThrowException(() => builder.UseModelFactory(modelFactory)); ShouldThrowException(() => builder.UseQueryProviderFactory(queryProviderFactory)); }
public Catalog(IDatabaseBuilder databaseBuild) { Services = new Dictionary<string, ICloudFoundryService>(); var sqlService = new MsSqlCloudFoundryService(new AppConfiguration(), databaseBuild); Services.Add(sqlService.Id, sqlService); }
/// <summary> /// Helium Execute SQL Query Actor constructor /// </summary> public HeliumExecuteSqlQueryActor(IDatabaseBuilder databaseBuilder) { _databaseBuilder = databaseBuilder ?? throw new ArgumentNullException(nameof(databaseBuilder)); _connectionStringActor = Context.ActorOf(Context.DI().Props <HeliumFileConnectionStringActor>()); Receive <HeliumExecuteSqlQueryMessage>(message => HandleExecuteSqlQuery(message)); Receive <HeliumGetConnectionStringResultMessage>(message => HandleConnectionStringResult(message)); }
public static IDatabase <TDatabase> Database <TDatabase>(this IDatabaseBuilder <TDatabase> @this, string name) { return(new InternalDatabaseBuilder <TDatabase>() { Name = name ?? throw BuilderError.ArgumentNull(nameof(name)).AsException(), Tables = new List <TableModel>() });
public void Build(IDatabaseBuilder Builder, string sStoredProcedure, params object[] arrobjParameters) { Builder.BuildConnection(); Builder.BuildCommand(sStoredProcedure); Builder.SetSettings(); Builder.AddParameters(arrobjParameters); Builder.GetDataReader(); }
public Catalog(IDatabaseBuilder databaseBuild) { Services = new Dictionary <string, ICloudFoundryService>(); var sqlService = new MsSqlCloudFoundryService(new AppConfiguration(), databaseBuild); Services.Add(sqlService.Id, sqlService); }
/// <summary> /// Initializes a new instance of the <see cref="KormBuilder"/> class. /// </summary> /// <param name="services">The service collection.</param> /// <param name="connectionSettings">The database connection settings.</param> public KormBuilder(IServiceCollection services, KormConnectionSettings connectionSettings) { Services = Check.NotNull(services, nameof(services)); ConnectionSettings = Check.NotNull(connectionSettings, nameof(connectionSettings)); Check.NotNullOrWhiteSpace( connectionSettings.ConnectionString, nameof(connectionSettings), Resources.EmptyConnectionStringInSettings); _builder = Database.Builder; _builder.UseConnection(connectionSettings); }
public void Constructor_GivenNullDatabaseBuilder_ShouldThrowException() { //---------------Set up test pack------------------- IDatabaseBuilder databaseBuilder = null; var actorProps = Props.Create <HeliumExecuteSqlQueryActor>(databaseBuilder); //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- EventFilter.Exception(typeof(ArgumentNullException), contains: "Parameter name: databaseBuilder", checkInnerExceptions: true) .Expect(1, () => Sys.ActorOf(actorProps, "Test")); //---------------Test Result ----------------------- }
protected override void Configure(IDatabaseBuilder builder) { base.Configure(builder); // This should be auto-discovered builder.Configure(new ProductTableConfiguration()); builder.Configure(new OwnerTableConfiguration()); builder.Configure(new ArchivedProductTableConfiguration()); builder.Configure(new AvailableProductViewConfiguration()); builder.Configure(new SearchProductsProcedureConfiguration()); builder.Configure(new CalculatePriceFunctionConfiguration()); }
private IActorRef CreateActor(IDatabaseBuilder databaseBuilder = null) { var databaseSettings = Substitute.For <IThuriaDatabaseSettings>(); databaseSettings.GetConnectionString("TestDbContext").Returns("TestConnectionString"); var container = new Container( expression => { expression.For <IThuriaDatabaseSettings>().Use(databaseSettings); expression.For <IDatabaseBuilder>().Use(databaseBuilder ?? Substitute.For <IDatabaseBuilder>()); }); var dependencyResolver = new StructureMapDependencyResolver(container, Sys); var actorProps = Sys.DI().Props <HeliumExecuteSqlQueryActor>(); return(Sys.ActorOf(actorProps, "Test")); }
public DatabaseManager( DatabaseManagerConfig config) { string[] keyValuePairs = config.CONNECTION_STRING.Split(new char[] { ';' }); string vendorType = "SqlServer"; foreach (string keyValuePair in keyValuePairs) { string[] tokens = keyValuePair.Split(new char[] { '=' }); if (tokens.Length == 2) { string key = tokens[0]; string value = tokens[1]; if (key == "DbLinqProvider") { vendorType = value; break; } } } if (vendorType == "Sqlite") { m_builder = new DatabaseBuilderSQLite(); } else { // Default to SqlServer if no vendor type is given m_builder = new DatabaseBuilderMSSQL(); } // Save off the config data m_config = config; }
public UI(ITicTacToeFactory gameFactory, IDatabaseBuilder databaseBuilder) { _gameFactory = gameFactory; _databaseBuilder = databaseBuilder; }
public void BuildBackup(IDatabaseBuilder builder) { builder.BuildConnection("BackupMySqlConn"); builder.BuildCommand(); builder.SetSettings(); }
public void BuildProduction(IDatabaseBuilder builder) { builder.BuildConnection("MySqlConn"); builder.BuildCommand(); builder.SetSettings(); }
protected virtual void Configure(IDatabaseBuilder builder) { // auto-discover configuration from assembly }
public void Build(IDatabaseBuilder Builder) { Builder.BuildConnection(); Builder.BuildCommand(); Builder.SetSettings(); }
public BuildDatabaseController(IDatabaseBuilder databaseBuilder) { _databaseBuilder = databaseBuilder; }
public static IDatabaseBuilder UseLogging(this IDatabaseBuilder database, ILogger logger) { return(database .UseDelegatingHandler(new LoggingHandler(logger))); }
public static IDatabaseBuilder UseCaching(this IDatabaseBuilder builder, IMemoryCache memoryCache) { return(builder.UseDelegatingHandler(new MemoryCachingHandler(memoryCache))); }
/// <summary> /// Use <paramref name="connectionString"/> which instance of <see cref="IDatabase"/> will use for accessing to database. /// </summary> /// <param name="builder">Databse builder.</param> /// <param name="connectionString">Connection string.</param> /// <returns>Database builder.</returns> public static IDatabaseBuilder UseConnection(this IDatabaseBuilder builder, string connectionString) => builder.UseConnection(new KormConnectionSettings() { ConnectionString = connectionString });