public AzureProcessor(IDbConnection connection, IMigrationGenerator generator, IAnnouncer announcer, IMigrationProcessorOptions options, IDbFactory factory)
: base(generator, announcer, options)
{
this.factory = factory;
Connection = connection;
connection.Open();
}
protected GenericProcessorBase(IDbConnection connection, IDbFactory factory
, IMigrationGenerator generator, IAnnouncer announcer, IMigrationProcessorOptions options)
: base(generator, announcer, options)
{
Connection = connection;
Factory = factory;
}
public NpgsqlCreateDatabaseDialog (IDbFactory factory):base(factory)
{
createDBWidget = new NpgsqlCreateDatabaseWidget ();
Notebook.AppendPage (createDBWidget,
new Label (AddinCatalog.GetString ("Database Properties")));
Notebook.ShowTabs = true;
Gtk.Notebook nb = Notebook;
nb.SwitchPage += delegate(object o, SwitchPageArgs args) {
if (nb.CurrentPage == 1)
if (!connectionWidget.ValidateFields ())
{
nb.CurrentPage = 0;
MessageService.ShowError (this,
AddinCatalog.GetString ("Set the connection properties before the database properties."));
} else {
Initialize (factory);
if (DatabaseConnection.ConnectionPool.HasErrors) {
MessageService.ShowError (DatabaseConnection.ConnectionPool.Error);
nb.CurrentPage = 0;
return;
}
createDBWidget.Initialize ((NpgsqlSchemaProvider)DatabaseConnection.SchemaProvider);
}
};
Notebook.ShowAll ();
}
protected override ConnectionSettingsWidget CreateConnectionSettingsWidget (IDbFactory factory)
{
connectionWidget = new ConnectionSettingsWidget (factory);
connectionWidget.ShowSettings (factory.GetDefaultConnectionSettings ());
connectionWidget.EnableTestButton = false;
return connectionWidget;
}
public static IConfigureHost WithSqlStorages(this IConfigureHost host,IDbFactory connection ,Action<StoragesConfiguration> cfgAction)
{
cfgAction.MustNotBeNull();
var cfg=new StoragesConfiguration(host,connection);
cfgAction(cfg);
return host;
}
protected void SetUp(IDbFactory dbFactory)
{
this.Factory = dbFactory;
this.Connection = this.Factory.CreateConnection(IntegrationTestOptions.Oracle.ConnectionString);
this.Processor = new OracleProcessor(this.Connection, new OracleGenerator(), new TextWriterAnnouncer(System.Console.Out), new ProcessorOptions(), this.Factory);
this.Connection.Open();
}
public SqlServerProcessor(DbConnection connection, IMigrationGenerator generator, IAnnouncer announcer, IMigrationProcessorOptions options, IDbFactory factory)
: base(generator, announcer, options)
{
this.factory = factory;
Connection = connection;
connection.Open();
BeginTransaction();
}
/// <summary>
/// 构造函数
/// </summary>
public DBSql(string strConnectionString, EnumDBType enumDBType)
{
_dbFactory = DBFactory.CreateInstance(enumDBType);
// 设置连接字符串
_DBConnectionString = strConnectionString;
CreateConnection();
}
public UnitOfWork(IDbFactory dbFactory)
{
if (dbFactory == null)
{
throw new ArgumentNullException("dbFactory");
}
_dbFactory = dbFactory;
}
public OracleProcessor(IDbConnection connection, IMigrationGenerator generator, IAnnouncer announcer, IMigrationProcessorOptions options, OracleDbFactory factory)
: base(generator, announcer, options)
{
Connection = connection;
_factory = factory;
//oracle does not support ddl transactions
//this.Transaction = this.Connection.BeginTransaction();
}
public DatabaseConnectionSettingsDialog (IDbFactory factory, DatabaseConnectionSettings settings)
: this (factory, true)
{
if (settings == null)
throw new ArgumentNullException ("settings");
settingsWidget.ShowSettings (settings);
settingsWidget.AppendDatabase (settings);
}
public DbDatabasePopulator(IDbFactory dbFactory, string connectionString)
{
if (dbFactory == null)
throw new ArgumentNullException("dbFactory");
if (connectionString == null)
throw new ArgumentNullException("connectionString");
this.dbFactory = dbFactory;
this.connectionString = connectionString;
}
public PostgresProcessor(IDbConnection connection, IMigrationGenerator generator, IAnnouncer announcer, IMigrationProcessorOptions options, IDbFactory factory)
: base(generator, announcer, options)
{
this.factory = factory;
Connection = connection;
connection.Open();
Announcer.Say("Beginning Transaction");
Transaction = Connection.BeginTransaction();
}
internal SqliteConnectionSettingsWidget (IDbFactory factory, bool isEditMode)
: base (factory, isEditMode)
{
EnableServerEntry = false;
EnablePortEntry = false;
EnableUsernameEntry = false;
EnablePasswordEntry = false;
EnableRefreshButton = false;
EnableOpenButton = true;
}
private void Initialize (IDbFactory factory)
{
if (DatabaseConnection != null)
DatabaseConnection.ConnectionPool.Close ();
DatabaseConnectionSettings settings = new DatabaseConnectionSettings(connectionWidget.ConnectionSettings);
settings.Database = "mysql";
// Create Context, Pool, Connection
DatabaseConnectionContext ctx = new DatabaseConnectionContext (settings, true);
ctx.ConnectionPool.Initialize ();
this.DatabaseConnection = ctx;
}
public static void ReceiveFromClientsBySql(this DispatchServerConfiguration cfg,IDbFactory connection,string table=CommunicatorTable,string dbSchema=CommunicatorSchema)
{
new ClientToServerRowCreator(connection).WithTableName(table, dbSchema).IfExists(TableExistsAction.Ignore).Create();
var configReceiver = new ConfigReceiver(connection);
cfg.EndpointUpdatesNotifier=configReceiver;
var fromClient = new ReceiverFromClient(connection);
cfg.MessageNotifier = fromClient;
}
public OracleTestTable(string table, IDbConnection connection, string schema, IDbFactory factory, params string[] columnDefinitions)
{
Connection = connection;
Factory = factory;
_schema = schema;
if (Connection.State != ConnectionState.Open)
Connection.Open();
Name = table;
Create(columnDefinitions);
}
bool IGuiProvider.ShowEditConnectionDialog(IDbFactory factory, DatabaseConnectionSettings settings, out DatabaseConnectionSettings newSettings)
{
DatabaseConnectionSettingsDialog dlg = new DatabaseConnectionSettingsDialog(factory, settings);
bool result = RunDialog (dlg);
if (result)
newSettings = dlg.ConnectionSettings;
else
newSettings = null;
Console.WriteLine("start edit connection dialog");
return result;
}
public bool ShowEditConnectionDialog (IDbFactory factory,
DatabaseConnectionSettings settings,
out DatabaseConnectionSettings newSettings)
{
DatabaseConnectionSettingsDialog dlg = new DatabaseConnectionSettingsDialog (factory, settings);
bool result = RunDialog (dlg);
if (result)
newSettings = dlg.ConnectionSettings;
else
newSettings = null;
return result;
/// <summary>
/// Initializes an instance of <see cref="DbAdministratorBase"/> with the connection string.
/// </summary>
/// <param name="connectionString">Connection string to the SQL server without initial catalog</param>
/// <param name="databaseName">Catalog name</param>
/// <param name="factory">The factory to use.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="connectionString"/> is a null reference (Nothing in Visual Basic)
/// </exception>
public DbAdministratorBase(string connectionString, string databaseName, IDbFactory factory)
{
if (connectionString==null)
throw new ArgumentNullException("connectionString");
if (databaseName==null)
throw new ArgumentNullException("databaseName");
if(factory==null)
throw new ArgumentNullException("factory");
this.connectionString=connectionString.TrimEnd(';');
this.databaseName=databaseName;
this.factory=factory;
}
protected GenericProcessorBase(IDbConnection connection, IDbFactory factory
, IMigrationGenerator generator, IAnnouncer announcer, IMigrationProcessorOptions options)
: base(generator, announcer, options)
{
Connection = connection;
// Prefetch connectionstring as after opening the security info could no longer be present
// for instance on sql server
connectionString = connection.ConnectionString;
Factory = factory;
}
public CreateDatabaseDialog (IDbFactory factory)
{
this.Build();
settingsWidget = CreateConnectionSettingsWidget (factory);
vboxConnection.PackStart (settingsWidget, true, true, 0);
settingsWidget.NeedsValidation += Validate;
settingsWidget.EnableRefreshButton = false;
ShowAll ();
}
public static void Init(IDbFactory fac,string dbSchema="")
{
using (var db = fac.Create())
{
db.CreateTableFrom<ServerStateItem>(c =>
{
c.TableName("dbus_server_state", dbSchema);
c.IgnoreIfExists();
c.ColumnSize(d => d.Data, "max");
});
db.Insert(new ServerStateItem() {Data = new DispatcherState().Serialize()});
}
}
private void BuildChildren (IDbFactory fac)
{
foreach (ExtensionNode node in ChildNodes) {
ActionCodon actionCodon = node as ActionCodon;
if (actionCodon != null) {
fac.SetSupportedActions (actionCodon.Category, actionCodon.Actions);
} else {
CapabilitiesCodon capabilitiesCodon = node as CapabilitiesCodon;
if (capabilitiesCodon != null)
fac.SetCapabilities (capabilitiesCodon.Category, capabilitiesCodon.Actions, capabilitiesCodon.ParsedFlags);
}
}
}
public FakeConnectionPool (IDbFactory factory, IConnectionProvider connectionProvider, DatabaseConnectionContext context)
{
if (factory == null)
throw new ArgumentNullException ("factory");
if (connectionProvider == null)
throw new ArgumentNullException ("connectionProvider");
if (context == null)
throw new ArgumentNullException ("context");
this.factory = factory;
this.connectionProvider = connectionProvider;
this.context = context;
}
/// <summary>
/// Initializes a <see cref="DbFixture"/> with a connection string.
/// </summary>
/// <param name="connectionString">
/// Connection string for accessing the test database.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="connectionString"/> is a null reference
/// (Nothing in Visual Basic)
/// </exception>
public DbFixture(string connectionString, string databaseName, IDbFactory factory)
{
if (connectionString==null)
throw new ArgumentNullException("connectionString");
if (databaseName==null)
throw new ArgumentNullException("databaseName");
if (factory==null)
throw new ArgumentNullException("factory");
this.connectionString=connectionString;
this.databaseName=databaseName;
this.factory=factory;
this.admin=
this.factory.CreateAdmin(this.connectionString,this.databaseName);
}
{
public bool ShowCreateDatabaseDialog (IDbFactory factory)
{
SqlServerCreateDatabaseDialog dialog = new SqlServerCreateDatabaseDialog (factory);
int resp;
do {
resp = dialog.Run ();
} while (resp != (int)ResponseType.Cancel &&
resp != (int)ResponseType.Ok &&
resp != (int)ResponseType.DeleteEvent);
dialog.Destroy ();
if (resp == (int)ResponseType.Ok)
return true;
else
return false;
public DbCommandUniqueValidatorBase(
ITablePopulator table,
UniqueConstraint unique,
IDbFactory dbFactory,
string connectionString
)
: base(table,unique)
{
if (dbFactory == null)
throw new ArgumentNullException("factory");
if (connectionString == null)
throw new ArgumentNullException("connectionString");
this.dbFactory = dbFactory;
this.connectionString = connectionString;
}
/// <summary>
/// Returns a connection for the current transaction. This will be an existing <see cref="DbConnection"/>
/// instance or a new one if there is a <see cref="TransactionScope"/> active. Otherwise this method
/// returns null.
/// </summary>
/// <param name="db"></param>
/// <returns>Either a <see cref="DbConnection"/> instance or null.</returns>
public static DbConnection GetConnection(string connectionString, IDbFactory dbFactory)
{
Transaction currentTransaction = Transaction.Current;
if (currentTransaction == null)
{
return null;
}
Dictionary<string, DbConnection> connectionList;
transactionConnections.TryGetValue(currentTransaction, out connectionList);
DbConnection connection;
if (connectionList != null)
{
connectionList.TryGetValue(connectionString, out connection);
if (connection != null)
{
return connection;
}
}
else
{ // We don't have a list for this transaction, so create a new one
connectionList = new Dictionary<string, DbConnection>();
lock (transactionConnections)
{
transactionConnections.Add(currentTransaction, connectionList);
}
}
//
// Next we'll see if there is already a connection. If not, we'll create a new connection and add it
// to the transaction's list of connections.
//
if (connectionList.ContainsKey(connectionString))
{
connection = connectionList[connectionString];
}
else
{
connection = dbFactory.CreateConnection(connectionString);
connection.Open();
currentTransaction.TransactionCompleted += new TransactionCompletedEventHandler(OnTransactionCompleted);
connectionList.Add(connectionString, connection);
}
return connection;
}
private static void Init()
{
var builder = Db.Db.Setup(new TestDbProvider());
builder.Table<Post>()
.Table<User>()
.Table<Tag>()
.Table<PostTag>()
.Table<Like>()
.Table<FollowUser>();
_factory = builder
.OneToMany<User, Post>(u => u.Posts, p => p.User)
.ManyToMany<Post, PostTag>(p => p.Tags)
.BuildFactory();
}
public ContactRepository(IDbFactory dbFactory) : base(dbFactory)
{
}
public OrderRepository(IDbFactory dbFactory) : base(dbFactory)
{
}
public BaseRepository(IDbFactory dbFactory)
{
this.dbFactory = dbFactory;
}
public ProductCategoryRepository(IDbFactory dbFactory) : base(dbFactory)
{
}
public FooterRepository(IDbFactory dbFactory) : base(dbFactory)
{
}
public DocumentCommercialDetailRepository(IDbFactory dbFactory) : base(dbFactory)
{
}
public SQLiteProcessor(IDbConnection connection, IMigrationGenerator generator, IAnnouncer announcer, IMigrationProcessorOptions options, IDbFactory factory)
: base(connection, factory, generator, announcer, options)
{
}
public PostTagRepository(IDbFactory dbFactory) : base(dbFactory)
{
}
public ApplicationRoleRepository(IDbFactory dbFactory) : base(dbFactory)
{
}
public RequisitionApprovalRepository(IDbFactory dbFactory) : base(dbFactory)
{
}
public EmployeeRepository(IDbFactory dbFactory)
: base(dbFactory)
{
}
public MenuRepository(IDbFactory dbFactory) : base(dbFactory)
{
}
public AdminSaleRepository(IDbFactory dbFactory)
: base(dbFactory)
{
}
public SlideRepository(IDbFactory dbFactory) : base(dbFactory)
{
}
public PageRepository(IDbFactory dbFactory) : base(dbFactory)
{
}
public VisitorStatisticRepository(IDbFactory dbFactory) : base(dbFactory)
{
}
public UnitOfWork(IDbFactory db)
{
this._db = db;
}
public ProductWarehouseRepository(IDbFactory dbFactory) : base(dbFactory)
{
}
public OACYRepository(IDbFactory dbfactory) : base(dbfactory)
{
}
public BookRepository(IDbFactory dbFactory)
: base(dbFactory)
{
}
public UnitOfWork(IDbFactory dbFactory)
{
_dbFactory = dbFactory;
}
public SysConfigRepository(IDbFactory factory, ICacheManager cache)
{
Factory = factory;
Cache = cache;
}
public AnnouncementUserRepository(IDbFactory dbFactory) : base(dbFactory)
{
}
public UnitOfWork(IDbFactory dbFactory)
{
this.dbFactory = dbFactory;
}
public FeedbackRepository(IDbFactory dbFactory) : base(dbFactory)
{
}
public void Initialize()
{
dbFactory = new DbFactory();
objRepository = new PostCategoryRepository(dbFactory);
unitOfWork = new UnitOfWork(dbFactory);
}
public CategoryRepository(IDbFactory dbFactory)
: base(dbFactory)
{
}
public FunctionRepository(IDbFactory dbFactory) : base(dbFactory)
{
}
public NganhNgheRepository(IDbFactory dbFactory) : base(dbFactory)
{
}
public DanhMucSPRepository(IDbFactory dbFactory) : base(dbFactory)
{
}
