/// <summary>
/// Releases the connection.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>The response.</returns>
private static ReleaseConnectionServiceResponse ReleaseConnection(ReleaseConnectionServiceRequest request)
{
SqliteDatabaseProvider databaseProvider = DatabaseConnectionManagementService.GetDatabaseProvider(request.RequestContext);
bool released = databaseProvider.ReleaseConnection(request.ConnectionString);
return(new ReleaseConnectionServiceResponse(released));
}
public ITerminologyProvider[] Browse(IWin32Window owner, ITerminologyProviderCredentialStore credentialStore)
{
var messageBoxService = new MessageBoxService();
if (IATEApplication.ConnectionProvider.EnsureConnection())
{
var sqlDatabaseProvider = new SqliteDatabaseProvider(new PathInfo());
var cacheProvider = new CacheProvider(sqlDatabaseProvider);
_settingsViewModel = new SettingsViewModel(null, IATEApplication.InventoriesProvider, cacheProvider, messageBoxService);
_settingsWindow = new SettingsWindow {
DataContext = _settingsViewModel
};
_settingsWindow.ShowDialog();
if (!_settingsViewModel.DialogResult)
{
return(null);
}
var settings = _settingsViewModel.ProviderSettings;
var provider = new IATETerminologyProvider(settings, IATEApplication.ConnectionProvider, IATEApplication.InventoriesProvider, cacheProvider);
return(new ITerminologyProvider[] { provider });
}
var exception = new Exception("Failed login!");
_logger.Error(exception);
throw exception;
}
public ITerminologyProvider CreateTerminologyProvider(Uri terminologyProviderUri, ITerminologyProviderCredentialStore credentials)
{
var savedSettings = SettingsService.GetSettingsForCurrentProject();
var savedTermTypesNumber = savedSettings?.TermTypes.Count;
if (savedTermTypesNumber > 0 && savedTermTypesNumber > IATEApplication.InventoriesProvider.TermTypes?.Count)
{
var availableTermTypes = GetAvailableTermTypes(savedSettings.TermTypes);
savedSettings.TermTypes = new List <TermTypeModel>(availableTermTypes);
}
if (!IATEApplication.ConnectionProvider.EnsureConnection())
{
var exception = new Exception("Failed login!");
_logger.Error(exception);
throw exception;
}
var sqlDatabaseProvider = new SqliteDatabaseProvider(new PathInfo());
var cacheProvider = new CacheProvider(sqlDatabaseProvider);
var terminologyProvider = new IATETerminologyProvider(savedSettings,
IATEApplication.ConnectionProvider, IATEApplication.InventoriesProvider, cacheProvider);
return(terminologyProvider);
}
public static void Fill(SqliteDatabaseProvider provider, IEnumerable <string> jsonResponses)
{
//1. create (temp) table
SqliteTableBuilder builder = CreateTable(provider);
provider.BulkInsert(builder.GetInsertStatements(ExtractEventNodes("owner", "repo", jsonResponses)));
}
/// <summary>
/// Assembles and executes a drop table statement.
/// </summary>
private void ExecuteDropTable()
{
using (var provider = new SqliteDatabaseProvider())
{
var deleteTempTableQuery = new SqlQuery("DROP TABLE IF EXISTS {0};", this.Table.TableName);
provider.ExecuteNonQuery(this.connection, deleteTempTableQuery);
}
}
public static SqliteTableBuilder CreateTable(SqliteDatabaseProvider provider)
{
Guard.ArgumentNotNull(provider, nameof(provider));
SqliteTableBuilder builder = RepositoryTableSnapshot.CreateTableBuilder();
provider.CreateTable(builder);
return(builder);
}
private static void Migrate(SqliteConnection connection)
{
var databaseProvider = new SqliteDatabaseProvider(connection);
var migrationsAssembly = typeof(Program).GetTypeInfo().Assembly;
var migrator = new SimpleMigrations.SimpleMigrator(migrationsAssembly, databaseProvider);
migrator.Load();
migrator.MigrateToLatest();
}
public void Start()
{
using (var uow = _dbFactory.Create <IUnitOfWork, IFooSession>(IsolationLevel.Serializable))
{
var databaseProvider = new SqliteDatabaseProvider(uow.Connection as System.Data.Common.DbConnection);
var migrator = new SimpleMigrator(Assembly.GetExecutingAssembly(), databaseProvider);
migrator.Load();
migrator.MigrateToLatest();
}
}
public static SqliteTableBuilder CreateTable(SqliteDatabaseProvider provider)
{
Guard.ArgumentNotNull(provider, nameof(provider));
SqliteTableBuilder builder = EventTableSnapshot.CreateTableBuilder();
provider.CreateTable(builder);
//foreach (string statement in builder.Build())
//{
// provider.Connection.Execute(statement); //execute create table and other DML Statements!
//}
return(builder);
}
/// <summary>
/// Assembles and executes a create table statement.
/// </summary>
private void ExecuteCreateTable()
{
const string CreateTempTable = "CREATE TEMP TABLE {0} ({1});";
string columnString = string.Join(", ", this.Table.Columns.Select(column => FormatColumn(column)));
using (var provider = new SqliteDatabaseProvider())
{
var deleteTempTableQuery = new SqlQuery(CreateTempTable, this.Table.TableName, columnString);
provider.ExecuteNonQuery(this.connection, deleteTempTableQuery);
}
}
/// <summary>
/// InMemory!
/// </summary>
/// <returns></returns>
public static ITableSnapshotBuilder EmptySnapshot()
{
TableSnapshotBuilder b = new TableSnapshotBuilder();
b.TableSnapshotDelegate = () =>
{
SqliteDatabaseProvider prov = SqliteDatabaseProvider.CreateInMemoryDatabase();
RepositoryListSnapshotBuilder.CreateTable(prov);
SqliteTableSnapshot ts = new SqliteTableSnapshot(prov, RepositoryTableSnapshot.TableName, RepositoryTableSnapshot.PrimaryKey);
return(ts);
};
return(b);
}
/// <summary>
/// Populates the temporary table in the database with the records presents in the <see cref="Table"/>.
/// </summary>
private void ExecutePopulateTable()
{
const string InsertTable = "INSERT INTO {0} ({1}) VALUES ({2});";
// for multiple row insertion, begining a transaction improves performance, because sqlite doesn't need to start
// a new transaction for every single insert.
using (var provider = new SqliteDatabaseProvider())
using (IDatabaseTransaction transaction = this.connection.BeginTransaction())
{
this.Table.ExecuteNonQuery(this.connection, provider, InsertTable);
transaction.Commit();
}
}
static void Main(string[] args)
{
var migrationsAssembly = typeof(Program).Assembly;
using (var connection = new SQLiteConnection("DataSource=database.sqlite"))
{
var databaseProvider = new SqliteDatabaseProvider(connection);
var migrator = new SimpleMigrator(migrationsAssembly, databaseProvider);
var runner = new ConsoleRunner(migrator);
runner.Run(args);
}
}
public static ITableSnapshotBuilder CreateInMemorySnapshotFromRequest(IEnumerable <string> jsonResponses)
{
Guard.ArgumentNotNull(jsonResponses, nameof(jsonResponses));
TableSnapshotBuilder b = new TableSnapshotBuilder();
b.TableSnapshotDelegate = () =>
{
SqliteDatabaseProvider prov = SqliteDatabaseProvider.CreateInMemoryDatabase();
Fill(prov, jsonResponses);
SqliteTableSnapshot ts = new SqliteTableSnapshot(prov, EventTableSnapshot.TableName, EventTableSnapshot.PrimaryKey);
return(ts);
};
return(b);
}
public static ITableSnapshotBuilder CreateFileSnapshotFromRequest(string fileName, IEnumerable <string> jsonResponses)
{
Guard.ArgumentNotNullOrEmptyString(fileName, nameof(fileName));
Guard.ArgumentNotNull(jsonResponses, nameof(jsonResponses));
TableSnapshotBuilder b = new TableSnapshotBuilder();
b.TableSnapshotDelegate = () =>
{
SqliteDatabaseProvider provider = SqliteDatabaseProvider.CreateDatabase(fileName);
RepositoryListSnapshotBuilder.Fill(provider, jsonResponses);
SqliteTableSnapshot ts = new SqliteTableSnapshot(provider, RepositoryTableSnapshot.TableName, RepositoryTableSnapshot.PrimaryKey);
return(ts);
};
return(b);
}
public static ITableSnapshotBuilder CreateFromFile(string fileName)
{
Guard.ArgumentNotNullOrEmptyString(fileName, nameof(fileName));
if (System.IO.File.Exists(fileName) == false)
{
throw new System.IO.FileNotFoundException("Snapshotfile not found", fileName);
}
TableSnapshotBuilder b = new TableSnapshotBuilder();
b.TableSnapshotDelegate = () =>
{
SqliteDatabaseProvider prov = SqliteDatabaseProvider.OpenDatabase(fileName);
SqliteTableSnapshot ts = new SqliteTableSnapshot(prov, RepositoryTableSnapshot.TableName, RepositoryTableSnapshot.PrimaryKey);
return(ts);
};
return(b);
}
public RepositoryListDifferTest()
{
this.DatabaseProvider = SqliteDatabaseProvider.CreateInMemoryDatabase();
}
/// <summary>
/// Executes a query string in the database.
/// </summary>
/// <param name="query">The query string to be executed.</param>
private void ExecuteQuery(string query)
{
var provider = new SqliteDatabaseProvider();
provider.ExecuteNonQuery(this.DatabaseConnection, new SqlQuery(query));
}
static void Main(string[] args)
{
using (var connection = new ConnectionFactory().Create())
{
var databaseProvider = new SqliteDatabaseProvider(connection);
var migrator = new SimpleMigrator(Assembly.GetEntryAssembly(), databaseProvider, new ConsoleLogger());
migrator.Load();
if (args.ElementAtOrDefault(0) == "migrate")
{
var runner = new ConsoleRunner(migrator);
runner.Run(args.Skip(1).ToArray());
return;
}
else
{
migrator.MigrateToLatest();
}
}
var clientConfig = new ClientConfig()
{
Server = "ircd.antonymale.co.uk",
Port = 6667,
IsSecure = false,
Nickname = "guarddog",
RealName = "guarddog",
Username = "******",
PermanentlyOp = true,
Channels =
{
new ChannelConfig()
{
Name = "#test"
},
new ChannelConfig()
{
Name = "#admin"
},
},
NickservPassword = "******",
RequireCommandPrefixInPrivmsg = true,
};
using (var client = new Client(clientConfig))
{
var banRepository = new BanRepository();
var aKickModuleConfig = new AKickModuleConfig()
{
Channels =
{
new AkickModuleChannelConfig()
{
OpChannel = client.Channels["#test"],
AdminChannels ={ client.Channels["#admin"] },
},
}
};
var akick = new AkickModule(client, aKickModuleConfig, banRepository);
akick.Load();
client.Open();
Console.ReadLine();
}
Console.WriteLine("Hello World!");
}
