public static void ConfigureDbContext(
DbContextOptionsBuilder optionsBuilder,
IDatabaseOptions databaseOptions
)
{
string connString = databaseOptions.CreateConnectionString();
if (IsInMemory(connString))
{
// Create a static connection simply to keep the connection alive
if (InMemoryConnection == null)
{
InMemoryConnection = new SqliteConnection(connString);
InMemoryConnection.Open();
}
optionsBuilder.UseSqlite(connString);
}
else
{
// Create a connection ourselves because we run into timeouts when seeding
// https://github.com/aspnet/EntityFrameworkCore/issues/18607
var conn = new SqliteConnection(connString)
{
DefaultTimeout = 180
};
optionsBuilder.UseSqlite(conn);
}
}
public MongoCollectionIntegrator(IDatabaseOptions settings)
{
var client = new MongoClient(settings.ConnectionString);
var database = client.GetDatabase(settings.DatabaseName);
_collection = database.GetCollection <T>(typeof(T).Name);
}
private void SetupScriptFolders(IDatabaseOptions database)
{
foreach (var source in _sources)
{
_logger.PostEntry("Setup script directory '{0}'.", source.SubFolder);
_scriptFileManager.SetupScriptDirectory(database.Name, source.SubFolder);
}
}
/// <summary>
/// Constructs the Context with the Database Options values provided
/// </summary>
/// <param name="options">The connection string and name of the Database to use</param>
public ContextProvider(IDatabaseOptions options)
{
// Create the (Singleton) Client, Database and then return the Context ready for use
Context = MongoProvider
.CreateMongoClient(options.ConnectionString)
.GetDatabase(options.DatabaseName)
.GetCollection <T>(Pluralizer.Pluralize(typeof(T).Name));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="options">Options for this table</param>
/// <param name="tableMetadata">The configuration for this table</param>
/// <param name="parentColumnName">The name of the column that points out an id in the parent table.</param>
/// <param name="parentTable">The parent table </param>
public ManyToOneSql(IDatabaseOptions options, ISqlTableMetadata tableMetadata, string parentColumnName,
CrudSql <TOneModel> parentTable)
: base(options, tableMetadata)
{
ParentColumnName = parentColumnName;
ParentTable = parentTable;
_convenience = new ManyToOneConvenience <TManyModel, TManyModel, Guid>(this);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="options"></param>
/// <param name="tableMetadata"></param>
protected TableBase(IDatabaseOptions options, ISqlTableMetadata tableMetadata)
{
InternalContract.RequireNotNull(options, nameof(options));
InternalContract.RequireValidated(tableMetadata, nameof(tableMetadata));
Database = new Database(options);
TableMetadata = tableMetadata;
}
/// <summary>
/// Add and use a Mongo database
/// </summary>
/// <param name="services">The services collection</param>
/// <param name="databaseOptions">The database configuration options</param>
/// <param name="healthCheckBuilder">An instance of the health check builder</param>
/// <param name="healthCheckTag">The tag to register the MongoDb health check against</param>
public static void AddMongoDataAccessLayer(this IServiceCollection services, IDatabaseOptions databaseOptions, IHealthChecksBuilder healthCheckBuilder = null, string healthCheckTag = null)
{
_ = databaseOptions ?? throw new ArgumentNullException(nameof(databaseOptions));
services.AddScoped(typeof(IDatabaseIntegrator <>), typeof(MongoCollectionIntegrator <>));
if (healthCheckBuilder != null)
{
healthCheckBuilder.AddMongoDb(databaseOptions.ConnectionString, databaseOptions.DatabaseName, null, new[] { healthCheckTag });
}
services.AddDataAccessLayer();
}
public ContextTests()
{
options = new DatabaseOptions
{
//! Testing provided via MongoDB running in Docker on localhost with no security
//* docker run --name mongo-test --mount source=mongodb-test,target=/data/db -p 27017:27017 mongo
ConnectionString = "mongodb://localhost",
DatabaseName = "CodeTest"
};
collection = new ContextProvider <TestModel>(options).Context;
// Insert the one document we'll try to select in the test
collection.InsertOne(new TestModel {
Name = "Bilbo", Age = 99
});
}
private void SetupScriptFolders(IDatabaseOptions database)
{
foreach (var source in _sources)
{
_logger.PostEntry("Setup script directory '{0}'.", source.SubFolder);
_scriptFileManager.SetupScriptDirectory(database.Name, source.SubFolder);
}
}
/// <summary> /// Add and use a Mongo database /// </summary> /// <param name="services">The services collection</param> /// <param name="databaseOptions">The database configuration options</param> public static void AddMongoDataAccessLayer(this IServiceCollection services, IDatabaseOptions databaseOptions) => AddMongoDataAccessLayer(services, databaseOptions, null);
/// <summary>
/// Constructor
/// </summary>
public CrudSql(IDatabaseOptions options, ISqlTableMetadata tableMetadata)
: base(options, tableMetadata)
{
}
public ReturnDbContext(IDatabaseOptions databaseOptions)
{
this._databaseOptions = databaseOptions;
}
public IdentityContextFactory(IDatabaseOptions databaseOptions)
{
_databaseOptions = databaseOptions;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="options"></param>
/// <param name="tableMetadata"></param>
/// <param name="groupColumnName1"></param>
/// <param name="referenceHandler1"></param>
/// <param name="groupColumnName2"></param>
/// <param name="referenceHandler2"></param>
public ManyToManySql(IDatabaseOptions options, ISqlTableMetadata tableMetadata, string groupColumnName1,
CrudSql <TReferenceModel1> referenceHandler1, string groupColumnName2,
CrudSql <TReferenceModel2> referenceHandler2)
: base(options, tableMetadata, groupColumnName1, referenceHandler1, groupColumnName2, referenceHandler2)
{
}
public DependentToMasterSql(IDatabaseOptions options, ISqlTableMetadata tableMetadata,
CrudSql <TDependentModel> dependentTableHandler, CrudSql <TMasterModel> masterTableHandler)
: base(options, tableMetadata, dependentTableHandler, masterTableHandler)
{
}
public SqlDataAccess(IDatabaseOptions databaseOptions)
{
this.databaseOptions = databaseOptions as DatabaseOptions;
}
public PokerTimeDbContext(IDatabaseOptions databaseOptions)
{
this._databaseOptions = databaseOptions;
}
/// <summary>
/// The constructor
/// </summary>
/// <param name="options">How to connect to the database.</param>
public Database(IDatabaseOptions options) : this(options?.ConnectionString)
{
InternalContract.RequireNotNull(options, nameof(options));
Options = options;
}
public MainDbContext(IDatabaseOptions databaseOptions)
{
_connection = new SQLiteAsyncConnection(databaseOptions.ConnectionString);
ManualMigration();
}
public SalesDbContext(IDatabaseOptions databaseOptions, DbContextOptions <SalesDbContext> options)
: base(options)
{
_databaseOptions = databaseOptions;
}
/// <inheritdoc />
public DistributedLockTable(IDatabaseOptions options) : base(options, Metadata)
{
}
