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);
}
public MsSqlCloudFoundryService(IConfiguration configuration, IDatabaseBuilder databaseBuilder)
{
this.configuration = configuration;
this.databaseBuilder = databaseBuilder;
Service = new MsSqlService();
Id = Service.Id;
}
/// <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 BuildDatabaseController(IDatabaseBuilder databaseBuilder)
{
_databaseBuilder = databaseBuilder;
}
public static IDatabaseBuilder UseCaching(this IDatabaseBuilder builder, IMemoryCache memoryCache)
{
return(builder.UseDelegatingHandler(new MemoryCachingHandler(memoryCache)));
}
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;
}
/// <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
});
