public static WPostFile GetFileByChanbName(string name, DbConnection con)
{
WPostFile pf = null;
using (DbCommand dc = DatabaseEngine.GenerateDbCommand(con))
{
dc.CommandText = "SELECT ID, postID, md5, realname, size, extension, mimetype, dimension FROM files WHERE (chanbname = @chanbname)";
dc.Parameters.Add(DatabaseEngine.MakeParameter("@chanbname", name, DbType.String));
using (DbDataReader reader = dc.ExecuteReader())
{
while (reader.Read())
{
if (Convert.IsDBNull(reader[0]))
{
break;
}
pf = new WPostFile()
{
PostID = Convert.ToInt32(ReadParam(reader[1])),
Hash = Convert.ToString(ReadParam(reader[2])),
ChanbName = name,
RealName = Convert.ToString(ReadParam(reader[3])),
Size = Convert.ToInt32(ReadParam(reader[4])),
Extension = Convert.ToString(ReadParam(reader[5])),
MimeType = Convert.ToString(ReadParam(reader[6])),
Dimensions = Convert.ToString(ReadParam(reader[7])),
};
}
}
}
return(pf);
}
private static WPostFile[] GetPostFiles(int id, DbConnection connection)
{
List <WPostFile> li = new List <WPostFile>();
using (DbCommand dc = DatabaseEngine.GenerateDbCommand(connection))
{
dc.CommandText = "SELECT ID, chanbname, realname, size, md5, extension, mimetype, dimension FROM files WHERE (postID = @postID)";
dc.Parameters.Add(DatabaseEngine.MakeParameter("@postID", id, DbType.Int32));
using (DbDataReader reader = dc.ExecuteReader())
{
while (reader.Read())
{
if (!Convert.IsDBNull(reader[0]))
{
li.Add(new WPostFile()
{
PostID = id,
ChanbName = Convert.ToString(ReadParam(reader[1])),
RealName = Convert.ToString(ReadParam(reader[2])),
Size = Convert.ToInt32(ReadParam(reader[3])),
Hash = Convert.ToString(ReadParam(reader[4])),
Extension = Convert.ToString(ReadParam(reader[5])),
MimeType = Convert.ToString(ReadParam(reader[6])),
Dimensions = Convert.ToString(ReadParam(reader[7]))
});
}
}
}
}
return(li.ToArray());
}
public static ThreadInfo GetThreadInfo(int id, DbConnection con)
{
using (DbCommand dc = DatabaseEngine.GenerateDbCommand(string.Format("SELECT ID, locked, mta FROM board WHERE (ID = {0})", id), con))
{
ThreadInfo info = new ThreadInfo();
using (DbDataReader reader = dc.ExecuteReader())
{
while (reader.Read())
{
if (Convert.IsDBNull(reader[0]))
{
info.isGone = true;
break;
}
else
{
info.isGone = false;
info.isLocked = reader.GetBoolean(1);
info.isArchived = reader.GetBoolean(2);
}
}
}
return(info);
}
}
public static bool CreateDatabase(DatabaseEngine database, DatabaseInfo databaseInfo)
{
switch (database)
{
case DatabaseEngine.MSSQL:
break;
case DatabaseEngine.MsSqlLocalStorage:
break;
case DatabaseEngine.MySql:
break;
case DatabaseEngine.PgSql:
break;
case DatabaseEngine.SqLite:
string path = GlobalConfig.ContentRootPath;
path = Path.Combine(path, "Data");
string dbFileName = Path.Combine(path, "NetCoreCMS.Database.SqLite.db");
using (var dbFile = File.Create(dbFileName)) { };
return(File.Exists(dbFileName));
}
return(false);
}
public static bool InitilizeDatabase(DatabaseEngine database, string connectionString)
{
var builder = new DbContextOptionsBuilder <NccDbContext>();
switch (database)
{
case DatabaseEngine.MSSQL:
builder.UseSqlServer(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework"));
break;
case DatabaseEngine.MsSqlLocalStorage:
break;
case DatabaseEngine.MySql:
builder.UseMySql(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework"));
break;
case DatabaseEngine.SqLite:
builder.UseSqlite(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework"));
break;
case DatabaseEngine.PgSql:
break;
}
//builder.UseSqlite(connectionString, options => options.MigrationsAssembly("NetCoreCMS.Framework"));
var dbContext = new NccDbContext(builder.Options);
dbContext.Database.Migrate();
return(dbContext.Database.EnsureCreated());
}
private IDbConnection GetConnection(DatabaseEngine providerType, string connectionString)
{
var provider = _connectionProviderFactory.GetInstance(providerType);
var cn = provider.GetCustomConnection(connectionString);
return(cn);
}
public DatabaseConfiguration(DatabaseEngine databaseEngine, string masterString, bool debugFlag, string migrationsAssembly)
{
_databaseEngine = databaseEngine;
_masterString = masterString;
_debugFlag = debugFlag;
_migrationsAssembly = migrationsAssembly;
}
public DatabaseDriver()
{
this.DatabaseEngine = Config.GetDatabaseEngine();
DbConnectionStringBuilder Builder;
if (this.DatabaseEngine == DatabaseEngine.Sqlite)
{
Builder = new SQLiteConnectionStringBuilder();
string FullPath = Path.Combine(Utils.AssemblyPath, Config.GetType <string>("Database", "Database") + ".sqlite3");
IsNewDatabase = !File.Exists(FullPath) || new FileInfo(FullPath).Length == 0;
Builder.Add("Data Source", FullPath);
Connection = new SQLiteConnection(Builder.ConnectionString);
}
else if (this.DatabaseEngine == DatabaseEngine.Mysql)
{
Builder = new MySqlConnectionStringBuilder();
Builder.Add("Server", Config.GetType <string>("Database", "Hostname"));
Builder.Add("Port", Config.GetType <int>("Database", "Port"));
Builder.Add("User ID", Config.GetType <string>("Database", "Username"));
Builder.Add("Password", Config.GetType <string>("Database", "Password"));
Builder.Add("Database", Config.GetType <string>("Database", "Database"));
Connection = new MySqlConnection(Builder.ConnectionString);
}
else
{
throw new Exception("Invalid Database type.");
}
}
public static UnitOfWorkTestContextDbStrategy For(DatabaseEngine databaseEngine, string databaseName, IDictionary<string, string> properties)
{
UnitOfWorkTestContextDbStrategy strategy;
switch (databaseEngine)
{
case DatabaseEngine.SQLite:
strategy = new SQlLiteUnitOfWorkTestContextDbStrategy();
break;
case DatabaseEngine.MsSqlCe:
strategy = new MsSqlCeUnitOfWorkTestContextDbStrategy(databaseName);
break;
case DatabaseEngine.MsSql2005:
strategy = new MsSql2005UnitOfWorkTestContextDbStrategy(databaseName);
break;
case DatabaseEngine.MsSql2005Express:
strategy = new MsSql2005ExpressUnitOfWorkTestContextDbStrategy(databaseName);
break;
default:
throw new ArgumentOutOfRangeException("databaseEngine");
}
if (properties != null)
foreach (KeyValuePair<string,string> property in properties)
strategy.NHibernateProperties[property.Key] = property.Value;
return strategy;
}
/// <param name="dbConnectionInfo">The database name and server (optional)</param>
/// <param name="databaseEngine">The database engine that tests should be performed against</param>
/// <remarks>
/// If <paramref name="dbConnectionInfo"/> is <see langword="null" /> or returns <see langword="null" />
/// or <see cref="string.Empty"/> for the <see cref="DbConnectionInfo.DatabaseName"/>, a database with a
/// name derived from the other parameters supplied will be created. See
/// <see cref="DeriveDatabaseNameFrom"/>
/// <para>
/// <paramref name="databaseEngine"/> largely determines the configuration of nhibernate. The argument
/// supplied is used to pick from the predefined <see cref="NhCommonConfigurations"/>
/// </para>
/// </remarks>
public NHibernateTestContextInitializer Using(DatabaseEngine databaseEngine, DbConnectionInfo dbConnectionInfo)
{
DatabaseEngine = databaseEngine;
ConnectionInfo = dbConnectionInfo;
return(this);
}
protected virtual bool TryConnection()
{
try
{
if (!this.is_ready)
{
this.CurDBEngine = new DatabaseEngine(base.PrivateConfig.DatabaseType, base.PrivateConfig.DatabaseConnectionString);
if (this.CurDBEngine.Connect())
{
this.is_ready = true;
}
else
{
this.error_occured = true;
base.ErrMsg = this.CurDBEngine.ErrorMessage;
}
}
}
catch (Exception exception)
{
this.error_occured = true;
base.ErrMsg = exception.Message;
}
return(this.is_ready);
}
public static void RegisterAuthServices(DatabaseEngine dbe)
{
switch (dbe)
{
case DatabaseEngine.MSSQL:
GlobalConfig.Services.AddDbContext <NccDbContext>(options =>
options.UseSqlServer(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework"))
);
break;
case DatabaseEngine.MsSqlLocalStorage:
break;
case DatabaseEngine.MySql:
GlobalConfig.Services.AddDbContext <NccDbContext>(options =>
options.UseMySql(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework"))
);
break;
case DatabaseEngine.SqLite:
GlobalConfig.Services.AddDbContext <NccDbContext>(options =>
options.UseSqlite(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework"))
);
break;
case DatabaseEngine.PgSql:
break;
}
GlobalConfig.Services.AddCustomizedIdentity();
}
public static void RegisterRepositories(this IServiceCollection services)
{
DatabaseEngine repositorytype = Enum.Parse <DatabaseEngine>(services.BuildServiceProvider().GetRequiredService <IOptions <InfrastructureSettings> >().Value.databaseEngine);
switch (repositorytype)
{
case DatabaseEngine.EntityFrameworkSQLite:
services.AddScoped <IShortUrlRepository, DbContextShortUrlRepository>();
services.AddScoped <IAdminRepository, DbContextAdminRepository>();
services.AddScoped <IStatRepository, DbContextStatRepository>();
services.AddScoped <IVisitorRepository, DbContextVisitorRepository>();
services.AddDbContext <CoreDbContext>(ServiceLifetime.Scoped);
break;
case DatabaseEngine.EntityFrameworkSQL:
services.AddScoped <IShortUrlRepository, DbContextShortUrlRepository>();
services.AddScoped <IAdminRepository, DbContextAdminRepository>();
services.AddScoped <IStatRepository, DbContextStatRepository>();
services.AddScoped <IVisitorRepository, DbContextVisitorRepository>();
services.AddDbContext <CoreDbContext>(ServiceLifetime.Scoped);
break;
case DatabaseEngine.Dapper:
services.AddScoped <IConnectionFactory, SQLConnectionFactory>();
services.AddScoped <IShortUrlRepository, SQLShortUrlRepository>();
services.AddScoped <IAdminRepository, SQLAdminRepository>();
services.AddScoped <IStatRepository, SQLStatRepository>();
services.AddScoped <IVisitorRepository, SQLVisitorRepository>();
break;
}
}
public DbCore(ref DatabaseEngine engine)
{
DbCommand command;
String idx = null;
if (engine != null)
{
_dbengine = engine;
}
else
{
throw(new ArgumentNullException("passed null engine param"));
}
// Create command object and create table
command = engine.CreateCommand();
command.CommandText = "CREATE TABLE IF NOT EXISTS " + TableName;
// TODO: Pull out remaining fields from the collectionbase, and run the SQL
command.ExecuteNonQuery();
command = null;
// do loop
command.CommandText = "CREATE INDEX idx_" + idx + " ON " + TableName + " (" + idx + ");";
//
}
public static NHibernateDbBuilder For(DatabaseEngine databaseEngine,
DbConnectionInfo dbConnectionInfo,
MappingInfo mappingInfo)
{
return(new NHibernateDbBuilder(DbMediaBuilder.For(databaseEngine, dbConnectionInfo),
NHibernateConfigurator.Create(databaseEngine, dbConnectionInfo, mappingInfo)));
}
public DatabaseConfiguration(DatabaseEngine databaseEngine, string connectionString, bool logging, string migrationsAssembly = "")
{
DatabaseEngine = databaseEngine;
ConnectionString = connectionString;
Logging = logging;
MigrationsAssembly = migrationsAssembly;
}
IDatabaseEngine OpenDatabase(string path, string user = null, bool useTransactions = true)
{
var databaseEngine = DatabaseEngine.CreateDatabaseEngine(path, user ?? Environment.UserName);
databaseEngine.UseTransactions = useTransactions;
return(databaseEngine);
}
internal static DbContextOptions GetDbContextOptions()
{
DatabaseEngine dbe = TypeConverter.TryParseDatabaseEnum(SetupHelper.SelectedDatabase);
var optionBuilder = new DbContextOptionsBuilder <NccDbContext>();
switch (dbe)
{
case DatabaseEngine.MSSQL:
optionBuilder.UseSqlServer(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework"));
return(optionBuilder.Options);
break;
case DatabaseEngine.MsSqlLocalStorage:
break;
case DatabaseEngine.MySql:
optionBuilder.UseMySql(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework"));
return(optionBuilder.Options);
break;
case DatabaseEngine.PgSql:
break;
case DatabaseEngine.SqLite:
optionBuilder.UseSqlite(SetupHelper.ConnectionString, opts => opts.MigrationsAssembly("NetCoreCMS.Framework"));
return(optionBuilder.Options);
}
return(null);
}
public void ExecuteDataScripts(DatabaseEngine engine)
{
if (engine != DatabaseEngine.SqlServer)
return;
//((SqlDatabase)Database.Main).ExecuteScript(ResourceLoader.LoadTextResource("Sprocket.Web.CMS.Pages.Widgets.SqlScripts.newsletter.sql"));
}
public static UnitOfWorkTestContextDbStrategy For(DatabaseEngine databaseEngine, string databaseName, IDictionary <string, string> properties)
{
UnitOfWorkTestContextDbStrategy strategy;
switch (databaseEngine)
{
case DatabaseEngine.SQLite:
strategy = new SQlLiteUnitOfWorkTestContextDbStrategy();
break;
case DatabaseEngine.MsSqlCe:
strategy = new MsSqlCeUnitOfWorkTestContextDbStrategy(databaseName);
break;
case DatabaseEngine.MsSql2005:
strategy = new MsSql2005UnitOfWorkTestContextDbStrategy(databaseName);
break;
case DatabaseEngine.MsSql2005Express:
strategy = new MsSql2005ExpressUnitOfWorkTestContextDbStrategy(databaseName);
break;
default:
throw new ArgumentOutOfRangeException("databaseEngine");
}
if (properties != null)
{
foreach (KeyValuePair <string, string> property in properties)
{
strategy.NHibernateProperties[property.Key] = property.Value;
}
}
return(strategy);
}
public async Task it_should_add_a_refresh_token(DatabaseEngine engine)
{
// Arrange
await using var container = new DatabaseTestContainerBuilder().Build(engine);
var configuration = new ConfigurationBuilder().For(container).Build(engine);
var manager = new DatabaseManagerBuilder().With(configuration).Build(engine);
var runner = new MigratorRunnerBuilder().With(configuration).Build(engine);
var sut = new UserRepositoryBuilder().With(configuration).Build(engine);
await container.StartAsync();
await manager.EnsureDatabaseCreated();
runner.MigrateUp();
const string username = "******";
var user = new UserBuilder().WithUserName(username).Build();
await sut.CreateAsync(user);
// Act
var persistedUser = await sut.FindByNameAsync(username);
await sut.AssignRefreshToken("some_token", persistedUser !);
// Assert
var result = await sut.FindByNameAsync(username);
result !.RefreshTokens.Should().ContainSingle("some_token");
}
/// <summary>
/// Executes the code to be tested.
/// </summary>
protected override void Act()
{
var extensionConfigurationProviders = A.Fake <IEnumerable <ExtensionNHibernateConfigurationProvider> >();
var beforeBindMappingActivities = A.Fake <IEnumerable <INHibernateBeforeBindMappingActivity> >();
var authorizationStrategyConfigurators = A.Fake <IEnumerable <INHibernateFilterConfigurator> >();
var filterCriteriaApplicatorProvider = A.Fake <IFilterCriteriaApplicatorProvider>();
var configurationActivities = A.Fake <IEnumerable <INHibernateConfigurationActivity> >();
var connectionStringProvider = A.Fake <IOdsDatabaseConnectionStringProvider>();
var assembliesProvider = A.Fake <AssembliesProvider>();
DatabaseEngine engine = DatabaseEngine.SqlServer;
var ormMappingFileDataProvider = new OrmMappingFileDataProvider(assembliesProvider, engine, OrmMappingFileConventions.OrmMappingAssembly);
var nHibernateConfigurator = new NHibernateConfigurator(extensionConfigurationProviders, beforeBindMappingActivities,
authorizationStrategyConfigurators, filterCriteriaApplicatorProvider, configurationActivities, ormMappingFileDataProvider, connectionStringProvider);
_configuration = nHibernateConfigurator.Configure();
_persistentClasses = _configuration.ClassMappings
.Where(
m => m.Table.Name.Equals(
CoreTableName,
StringComparison.InvariantCultureIgnoreCase))
.ToList();
}
public NHibernateInitializer Using(DatabaseEngine databaseEngine, string databaseName)
{
this.databaseEngine = databaseEngine;
this.databaseName = databaseName;
return(this);
}
protected virtual bool TryConnection()
{
CloseConnections();
clsLog oLog = new clsLog();
try
{
if (!this.is_ready)
{
this.CurDBEngine = new DatabaseEngine(base.PrivateConfig.DatabaseType, base.PrivateConfig.DatabaseConnectionString);
if (this.CurDBEngine.Connect())
{
this.is_ready = true;
oLog.WriteToDebugLogFile("Connected", "TryConnection");
}
else
{
this.error_occured = true;
base.ErrMsg = this.CurDBEngine.ErrorMessage;
}
}
}
catch (Exception exception)
{
this.error_occured = true;
base.ErrMsg = exception.Message;
}
return(this.is_ready);
}
public void Initialize()
{
databaseEngine = new DatabaseEngine
{
Database = Substitute.For <IDatabase>()
};
}
public SessionConfig(TypeOfDatabase DatabaseType, string DatabaseConnectionString) : base(DatabaseType, DatabaseConnectionString)
{
this.current_user = null;
this.CurDBEngine = null;
this.CurDBEngine = new DatabaseEngine(DatabaseType, DatabaseConnectionString);
this.CurDBEngine.Connect();
}
public override void Dispose()
{
clsLog oLog = new clsLog();
oLog.WriteToDebugLogFile("Starting Function", "Dispose");
if (this.is_detroyable)
{
oLog.WriteToDebugLogFile("Before Destroy", "Dispose");
if (this.IsReady)
{
oLog.WriteToDebugLogFile("Before Disconnect", "Dispose");
if (CurDBEngine != null)
{
this.CurDBEngine.Disconnect();
oLog.WriteToDebugLogFile("After Disconnect", "Dispose");
}
else
{
oLog.WriteToDebugLogFile("DB Engine is Null", "Dispose");
}
}
this.CurDBEngine = null;
this.CurSQLFactory = null;
oLog.WriteToDebugLogFile("Ending Function", "Dispose");
}
}
public async Task it_should_create_a_user(DatabaseEngine engine)
{
// Arrange
await using var container = new DatabaseTestContainerBuilder().Build(engine);
var configuration = new ConfigurationBuilder().For(container).Build(engine);
var manager = new DatabaseManagerBuilder().With(configuration).Build(engine);
var runner = new MigratorRunnerBuilder().With(configuration).Build(engine);
var sut = new UserRepositoryBuilder().With(configuration).Build(engine);
await container.StartAsync();
await manager.EnsureDatabaseCreated();
runner.MigrateUp();
// Act
const string username = "******";
var user = new UserBuilder().WithUserName(username).Build();
await sut.CreateAsync(user);
// Assert
var result = await sut.FindByNameAsync(username);
result.Should().BeEquivalentTo(user, opt => opt.Excluding(x => x.Id));
}
public ExtensionNHibernateConfigurationProvider(IDomainModelProvider domainModelProvider,
IAssembliesProvider assembliesProvider, DatabaseEngine databaseEngine, string assemblyName)
{
_assembliesProvider = Preconditions.ThrowIfNull(assembliesProvider, nameof(assembliesProvider));
_databaseEngine = Preconditions.ThrowIfNull(databaseEngine, nameof(databaseEngine));
_domainModel = Preconditions.ThrowIfNull(domainModelProvider, nameof(domainModelProvider)).GetDomainModel();
_assemblyName = Preconditions.ThrowIfNull(assemblyName, nameof(assemblyName));
}
public static NHibernateConfigurator Create(DatabaseEngine databaseEngine,
DbConnectionInfo dbConnectionInfo,
MappingInfo mappingInfo)
{
IDictionary <string, string> properties = NhCommonConfigurations.For(databaseEngine, dbConnectionInfo, true);
return(new NHibernateConfigurator(mappingInfo, properties));
}
public static void IntializeNHibernateAndIoC(PersistenceFramework framework,
string rhinoContainerConfig,
DatabaseEngine databaseEngine,
string databaseName,
MappingInfo mappingInfo)
{
InitializeNHibernateAndIoC(framework, rhinoContainerConfig, databaseEngine, databaseName, mappingInfo);
}
public TestcontainerDatabase Build(DatabaseEngine engine)
{
return(engine switch
{
DatabaseEngine.Postgres => CreatePostgresContainer(),
DatabaseEngine.SqlServer => CreateMsSqlContainer(),
_ => throw new ArgumentOutOfRangeException(nameof(engine), engine, $"Unknown engine {engine}")
});
/// <summary>
/// Initialize the persistence framework, build a session factory, and
/// initialize the container. If <paramref name="rhinoContainerConfig"/>
/// is <see langword="null" /> or <see cref="string.Empty">string.Empty</see>
/// a <see cref="RhinoContainer">RhinoContainer</see> will not be initialized.
/// </summary>
/// <param name="framework">The persistence framework</param>
/// <param name="rhinoContainerConfig">The configuration file to initialize a
/// <see cref="RhinoContainer">RhinoContainer</see> or <see langword="null" />.</param>
/// <param name="databaseName">Name of the database or <see langword="null" />.</param>
/// <param name="databaseEngine">The database engine that tests should be performed against</param>
/// <param name="mappingInfo">Information used to map classes to database tables and queries.</param>
/// <remarks>
/// If <paramref name="databaseName"/> is <see langword="null" /> or
/// <see cref="string.Empty"/> a database with a name
/// derived from the other parameters supplied will be created. See
/// <see cref="NHibernateInitializer.DeriveDatabaseNameFrom(Assembly)"/> and <see cref="NHibernateInitializer.DeriveDatabaseNameFrom(DatabaseEngine, Assembly)"/>
/// </remarks>
public static void InitializeNHibernateAndIoC(PersistenceFramework framework,
string rhinoContainerConfig,
DatabaseEngine databaseEngine,
string databaseName,
MappingInfo mappingInfo)
{
NHibernateInitializer.Initialize(framework, mappingInfo).Using(databaseEngine, databaseName).AndIoC(
rhinoContainerConfig);
}
/// <summary>
/// NHibernate 용 Domain을 테스트하기 위해, 환경을 초기화합니다.
/// </summary>
/// <param name="containerConfigPath">Castle Windsor configuration file path</param>
/// <param name="databaseEngine">Database 종류</param>
/// <param name="databaseName">Database name</param>
/// <param name="mappingInfo">Domain Model의 Mapping information</param>
/// <param name="configAction">configuration 부가 작업</param>
public static void InitializeNHibernateAndIoC(string containerConfigPath,
DatabaseEngine databaseEngine,
string databaseName,
MappingInfo mappingInfo,
Action<NHibernate.Cfg.Configuration> configAction) {
NHibernateInitializer.Initialize(mappingInfo, configAction)
.Using(databaseEngine, databaseName)
.AndIoC(containerConfigPath);
}
public DatabaseInventory(ManagementConnectionProvider database, string schemaName)
: base()
{
if (database == null) {
throw new ArgumentNullException("database");
}
targetEngine = database.Engine;
this.schemaName = schemaName;
XsltArgumentList arguments = CreateArguments(database);
using (SqlCommand command = database.GetConnection().CreateCommand()) {
command.Transaction = database.GetTransaction();
command.CommandType = CommandType.Text;
command.Parameters.AddWithValue("@sSchema", schemaName);
using (StringWriter writer = new StringWriter()) {
userObjectList.Transform(new XDocument().CreateReader(), arguments, writer);
command.CommandText = Regex.Replace(writer.ToString(), @"\s+", " ");
// ReSharper disable AccessToDisposedClosure
log.Trace(l => l(writer.ToString()));
// ReSharper restore AccessToDisposedClosure
}
using (SqlDataReader reader = command.ExecuteReader(CommandBehavior.SingleResult)) {
int definitionColumn = reader.GetOrdinal("xDefinition");
int nameColumn = reader.GetOrdinal("sName");
StringBuilder builder = new StringBuilder(65520);
while (reader.Read()) {
builder.Length = 0;
using (StringWriter writer = new StringWriter(builder)) {
SqlXml xml = reader.GetSqlXml(definitionColumn);
scripter.Transform(xml.CreateReader(), arguments, writer);
// ReSharper disable AccessToDisposedClosure
log.Trace(l => l("Object name: {0}\n XML: {1}\n SQL: {2}", reader.GetString(nameColumn), xml.Value, writer));
// ReSharper restore AccessToDisposedClosure
}
try {
try {
using (StringReader scriptReader = new StringReader(builder.ToString())) {
CreateStatement objectStatement = ProcessSingleScript(scriptReader, statement => {
log.Error(l => l("Cannot process statement error: {0}", statement));
throw CreateException("Cannot process statement:", statement, TargetEngine);
}).SingleOrDefault(statement => objectsToRename.Any(t => t.IsAssignableFrom(statement.GetType())));
if (objectStatement != null) {
objectStatement.ObjectName = reader.GetString(nameColumn);
}
}
} catch (ParseException ex) {
ex.FileName = reader.GetString(nameColumn);
throw;
}
} catch {
Trace.WriteLine(builder.ToString());
throw;
}
}
}
}
}
/// <summary>
/// NHibernate 용 Domain을 테스트하기 위해, 환경을 초기화합니다.
/// </summary>
/// <param name="containerConfigPath">Castle Windsor configuration file path</param>
/// <param name="databaseEngine">Database 종류</param>
/// <param name="databaseName">Database name</param>
/// <param name="mappingInfo">Domain Model의 Mapping information</param>
/// <param name="properties">NHibernate configuration 정보</param>
public static void InitializeNHibernateAndIoC(string containerConfigPath,
DatabaseEngine databaseEngine,
string databaseName,
MappingInfo mappingInfo,
IDictionary<string, string> properties) {
NHibernateInitializer.Initialize(mappingInfo, null)
.Using(databaseEngine, databaseName)
.ConfiguredBy(properties)
.AndIoC(containerConfigPath);
}
public static string DeriveDatabaseNameFrom(DatabaseEngine databaseEngine, Assembly assembly)
{
if (databaseEngine == DatabaseEngine.SQLite)
return UnitOfWorkTestContextDbStrategy.SQLiteDbName;
else if (databaseEngine == DatabaseEngine.MsSqlCe)
return "TempDB.sdf";
else // we want to have a test DB and a real db, and we really don't want to override on by mistake
return DeriveDatabaseNameFrom(assembly) + "_Test";
}
public static void IntializeNHibernateAndIoC(PersistenceFramework framework,
string rhinoContainerConfig,
DatabaseEngine databaseEngine,
string databaseName,
MappingInfo mappingInfo,
IDictionary<string, string> properties)
{
NHibernateInitializer.Initialize(framework, mappingInfo)
.Using(databaseEngine, databaseName)
.ConfiguredBy(properties)
.AndIoC(rhinoContainerConfig);
}
protected void VerifyCanCreateUnitOfWorkContextFor(PersistenceFramework framework,
string rhinoContainerPath,
DatabaseEngine databaseEngine,
string databaseName)
{
int nextContextPosition = Contexts.Count;
//creates the UnitOfWorkContext
MappingInfo mappingInfo = MappingInfo.FromAssemblyContaining<AREntity>();
InitializeNHibernateAndIoC(framework,
rhinoContainerPath,
databaseEngine,
databaseName,
mappingInfo);
UnitOfWorkTestContext context = Contexts[nextContextPosition];
Assert.AreEqual(framework, context.Framework);
if (rhinoContainerPath != null)
{
Assert.AreEqual(rhinoContainerPath, context.RhinoContainerConfigPath);
}
else
{
Assert.IsEmpty(context.RhinoContainerConfigPath);
}
Assert.AreEqual(databaseEngine, context.DatabaseEngine);
if (string.IsNullOrEmpty(databaseName))
{
Assert.AreEqual(
NHibernateInitializer.DeriveDatabaseNameFrom(databaseEngine, mappingInfo.MappingAssemblies[0]),
context.DatabaseName);
}
else
{
Assert.AreEqual(databaseName, context.DatabaseName);
}
Assert.AreEqual(CurrentContext,
context,
"Context just built has been assigned to CurrentContext");
}
public static UnitOfWorkTestContextDbStrategy For(DatabaseEngine databaseEngine, string databaseName)
{
return For(databaseEngine, databaseName, null);
}
/// <summary>
/// 특정 Database System 종류에 대한 테스트용 DB 생성 및 UnitOfWork의 환경설정 정보를 제공하는
/// UnitOfWorkTestContextDbStrategy의 인스턴스를 빌드한다.
/// </summary>
/// <param name="databaseEngine">Database system 종류</param>
/// <param name="databaseName">테스트용 Database name</param>
/// <param name="properties">NHibernate configuration properties</param>
/// <returns></returns>
public static UnitOfWorkTestContextDbStrategy For(DatabaseEngine databaseEngine, string databaseName,
IDictionary<string, string> properties) {
UnitOfWorkTestContextDbStrategy strategy;
switch(databaseEngine) {
case DatabaseEngine.SQLite:
strategy = new SQLiteUnitOfWorkTestContextDbStrategy();
break;
case DatabaseEngine.SQLiteForFile:
strategy = new SQLiteForFileUnitOfWorkTestContextDbStrategy(databaseName);
break;
case DatabaseEngine.MsSqlCe:
strategy = new MsSqlCeUnitOfWorkTestContextDbStrategy(databaseName);
break;
case DatabaseEngine.MsSqlCe40:
strategy = new MsSqlCe40UnitOfWorkTestContextDbStrategy(databaseName);
break;
case DatabaseEngine.MsSql2005:
strategy = new MsSql2005UnitOfWorkTestContextDbStrategy(databaseName);
break;
case DatabaseEngine.MsSql2005Express:
strategy = new MsSql2005ExpressUnitOfWorkTestContextDbStrategy(databaseName);
break;
case DatabaseEngine.OdpNet:
strategy = new OdpNetUnitOfWorkTestContextDbStrategy(databaseName);
break;
case DatabaseEngine.DevartOracle:
strategy = new DevartOdpNetUnitOfWorkTestContextDbStrategy(databaseName);
break;
case DatabaseEngine.MySql:
strategy = new MySqlUnitOfWorkTestContextDbStrategy(databaseName);
break;
case DatabaseEngine.PostgreSql:
strategy = new PostgreSqlUnitOfWorkTestContextDbStrategy(databaseName);
break;
case DatabaseEngine.Firebird:
strategy = new FireBirdUnitOfWorkTestContextDbStrategy(databaseName);
break;
case DatabaseEngine.Cubrid:
strategy = new CubridUnitOfWorkTestContextDbStrategy(databaseName);
break;
default:
throw new NotSupportedException("currently not support a specified database engine=" + databaseEngine);
}
if(properties != null)
foreach(var property in properties)
strategy.NHibernateProperties[property.Key] = property.Value;
return strategy;
}
public bool SupportsDatabaseEngine(DatabaseEngine engine)
{
return engine == DatabaseEngine.SqlServer;
}
public void DeleteDatabaseStructure(DatabaseEngine engine)
{
}
public NHibernateInitializer Using(DatabaseEngine databaseEngine, string databaseName) {
MappingContext.DatabaseEngine = databaseEngine;
_databaseEngine = databaseEngine;
_databaseName = databaseName;
return this;
}
public static string DeriveDatabaseNameFrom(DatabaseEngine databaseEngine, Assembly assembly) {
string dbName;
if(databaseEngine == DatabaseEngine.SQLite)
dbName = UnitOfWorkTestContextDbStrategy.SQLiteDbName;
//else if(databaseEngine == DatabaseEngine.MsSqlCe)
// dbName = "TempDB.sdf";
else
dbName = DeriveDatabaseNameFrom(assembly) + @"_Test";
if(IsDebugEnabled)
log.Debug("Drived Database name is [{0}]", dbName);
return dbName;
}
internal static Exception CreateException(string message, SqlScriptableToken token, DatabaseEngine targetEngine)
{
StringWriter writer = new StringWriter();
writer.WriteLine(message);
token.WriteTo(new SqlWriter(writer, targetEngine));
return new InvalidOperationException(writer.ToString());
}
public void ExecuteDataScripts(DatabaseEngine engine)
{
((SqlDatabase)Database.Main).ExecuteScript(ResourceLoader.LoadTextResource("Sprocket.Web.FileManager.DatabaseScripts.tables.sql"));
((SqlDatabase)Database.Main).ExecuteScript(ResourceLoader.LoadTextResource("Sprocket.Web.FileManager.DatabaseScripts.procedures.sql"));
}
public override bool DoesApplyToEngine(DatabaseEngine engine) {
if (engine == DatabaseEngine.SqlAzure) {
return false;
}
return base.DoesApplyToEngine(engine);
}
public static void IntializeNHibernateAndIoC(PersistenceFramework framework, string rhinoContainerConfig, DatabaseEngine databaseEngine, MappingInfo mappingInfo)
{
InitializeNHibernateAndIoC(framework, rhinoContainerConfig, databaseEngine, mappingInfo);
}
public NHibernateInitializer Using(DatabaseEngine databaseEngine, string databaseName)
{
this.databaseEngine = databaseEngine;
this.databaseName = databaseName;
return this;
}
public ManagementConnectionProvider(SqlConnection connection, string schemaName)
{
if (connection == null) {
throw new ArgumentNullException("connection");
}
if (String.IsNullOrEmpty(schemaName)) {
throw new ArgumentNullException("schemaName");
}
this.schemaName = schemaName;
if (connection.State == ConnectionState.Closed) {
closeConnection = true;
try {
connection.Open();
} catch {
connection.Dispose();
throw;
}
}
this.connection = connection;
using (SqlCommand cmd = connection.CreateCommand()) {
cmd.CommandType = CommandType.Text;
cmd.CommandText = "SELECT SERVERPROPERTY('productversion')";
engineVersion = new Version((string)cmd.ExecuteScalar());
cmd.CommandText = "SELECT SERVERPROPERTY('productlevel')";
engineLevel = (string)cmd.ExecuteScalar();
cmd.CommandText = "SELECT SERVERPROPERTY('edition')";
engineEdition = (string)cmd.ExecuteScalar();
if (engineEdition.IndexOf("Azure", StringComparison.OrdinalIgnoreCase) >= 0) {
engine = DatabaseEngine.SqlAzure;
} else {
switch (engineVersion.Major) {
case 9:
engine = DatabaseEngine.SqlServer2005;
break;
case 10:
engine = DatabaseEngine.SqlServer2008;
break;
case 11:
engine = DatabaseEngine.SqlServer2012;
break;
default:
engine = DatabaseEngine.Unknown;
break;
}
}
}
log.DebugFormat("Detected server: {0}", engine);
}
/// <summary>
/// NHibernate 용 Domain을 테스트하기 위해, 환경을 초기화합니다.
/// </summary>
/// <param name="containerConfigPath">Castle Windsor configuration file path</param>
/// <param name="databaseEngine">Database 종류</param>
/// <param name="mappingInfo">Domain Model의 Mapping information</param>
/// <param name="configAction">부가적인 Configuration 관련 작업 (Listener 추가 등)</param>
/// <param name="conventions">Fluent NHibernate의 명명규칙</param>
public static void InitializeNHibernateAndIoC(string containerConfigPath,
DatabaseEngine databaseEngine,
MappingInfo mappingInfo,
Action<NHibernate.Cfg.Configuration> configAction,
params IConvention[] conventions) {
NHibernateInitializer
.Initialize(mappingInfo, configAction, conventions)
.Using(databaseEngine, null)
.AndIoC(containerConfigPath);
}
public void ExecuteDataScripts(DatabaseEngine engine)
{
string sql = ResourceLoader.LoadTextResource("Sprocket.Web.CMS.Security.DatabaseScripts.sqlserver_data_001.sql");
((SqlDatabase)Database.Main).ExecuteScript(sql);
}
/// <summary>
/// NHibernate 용 Domain을 테스트하기 위해, 환경을 초기화합니다.
/// </summary>
/// <param name="containerConfigPath">Castle Windsor configuration file path</param>
/// <param name="databaseEngine">Database 종류</param>
/// <param name="databaseName">Database name</param>
/// <param name="mappingInfo">Domain Model의 Mapping information</param>
/// <param name="properties">NHibernate configuration 정보</param>
/// <param name="configAction">NHIbernate configuration 을 추가해야 할 경우 (Listner 등)</param>
/// <param name="conventions">Fluent NHibernate의 명명규칙</param>
public static void InitializeNHibernateAndIoC(string containerConfigPath,
DatabaseEngine databaseEngine,
string databaseName,
MappingInfo mappingInfo,
IDictionary<string, string> properties,
Action<NHibernate.Cfg.Configuration> configAction,
params IConvention[] conventions) {
NHibernateInitializer
.Initialize(mappingInfo, configAction, conventions)
.Using(databaseEngine, databaseName)
.ConfiguredBy(properties)
.AndIoC(containerConfigPath);
}
public void ExecuteDataScripts(DatabaseEngine engine)
{
((SqlDatabase)Database.Main).ExecuteScript(ResourceLoader.LoadTextResource("Sprocket.Web.Merchant.PayPal.Database.tables.sql"));
((SqlDatabase)Database.Main).ExecuteScript(ResourceLoader.LoadTextResource("Sprocket.Web.Merchant.PayPal.Database.procs.sql"));
}
protected void InitializeNHibernateAndIoC(string rhinoContainerPath,
DatabaseEngine databaseEngine,
string databaseName)
{
InitializeNHibernateAndIoC(FrameworkToTest,
rhinoContainerPath,
databaseEngine,
databaseName,
MappingInfo.FromAssemblyContaining<AREntity>());
}
/// <summary>
/// Creates the physical database named <paramref name="databaseName"/>.
/// </summary>
/// <remarks>
/// Use this method to create the physical database file.
/// <para>
/// For MsSqlCe this will create a database file in the file system
/// named <paramref name="databaseName"/>.sdf
/// </para>
/// <para>
/// For MsSql2005 this will create a database named <paramref
/// name="databaseName"/> in the (local) instance of Sql Server 2005 on
/// this machine
/// </para>
/// </remarks>
public static void CreatePhysicalDatabaseMediaFor(DatabaseEngine databaseEngine, string databaseName)
{
For(databaseEngine, databaseName, null).CreateDatabaseMedia();
}
protected void VerifyCanCreateUnitOfWorkContextFor(string rhinoContainerPath,
DatabaseEngine databaseEngine,
string databaseName)
{
VerifyCanCreateUnitOfWorkContextFor(FrameworkToTest,
rhinoContainerPath,
databaseEngine,
databaseName);
}
public static void IntializeNHibernateAndIoC(PersistenceFramework framework,
string rhinoContainerConfig,
DatabaseEngine databaseEngine,
string databaseName,
MappingInfo mappingInfo,
IDictionary<string, string> properties)
{
InitializeNHibernateAndIoC(framework, rhinoContainerConfig, databaseEngine, databaseName, mappingInfo, properties);
}
public virtual bool DoesApplyToEngine(DatabaseEngine engine) {
return true;
}
