/// <summary>
/// Sets up the database connection. If not provided, then
/// reads the connection from the config file.
/// </summary>
protected override void SetupDatabaseConnection()
{
if (DatabaseConnection.CurrentConnection != null)
{
return;
}
if (_databaseConfig == null)
{
_databaseConfig = Habanero.DB.DatabaseConfig.ReadFromConfigFile();
}
if (_databaseConfig.IsInMemoryDB())
{
BORegistry.DataAccessor = new DataAccessorInMemory();
}
else
{
ISupportsRSADecryption encryptedDatabaseConfig = _databaseConfig as ISupportsRSADecryption;
if (_privateKey != null && encryptedDatabaseConfig != null)
{
encryptedDatabaseConfig.SetPrivateKeyFromXML(_privateKey);
}
DatabaseConnection.CurrentConnection = _databaseConfig.GetDatabaseConnection();
BORegistry.DataAccessor = new DataAccessorDB();
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
DapperConfiguration.Configure();
IDatabaseConfig dbConfig = this.Configuration.GetSection("DatabaseConfig").Get <DatabaseConfiguration>();
services.AddSingleton(dbConfig);
services.AddControllersWithViews()
#if DEBUG
.AddRazorRuntimeCompilation()
#endif
.AddJsonOptions(options =>
{
options.JsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
options.JsonSerializerOptions.Encoder = JavaScriptEncoder.Create(UnicodeRanges.All);
});
if (dbConfig.InMemoryMode)
{
services.AddMemoryDatabaseModeServices();
}
else
{
services.AddMySqlDatabaseModeServices();
}
services.AddRealtimeServices();
services.AddSignalR();
}
/// <inheritdoc />
public virtual TestConnectionResult TestConnection(IDatabaseConfig config)
{
if (string.IsNullOrWhiteSpace(config.Database))
{
return(TestConnectionResult.ConnectionError);
}
if (!TestDatabaseConnection(config))
{
return(TestConnectionResult.ConnectionError);
}
var context = CreateContext(config, ContextMode.AllOff);
try
{
return(context.Database.Exists()
? TestConnectionResult.Success
: TestConnectionResult.ConnectionOkDbDoesNotExist);
}
catch
{
return(TestConnectionResult.ConnectionOkDbDoesNotExist);
}
finally
{
context.Dispose();
}
}
public Config(IDatabaseConfig database, IApplicationConfig application, List<ICounterGroup> groups, List<ITag> tags)
{
_database = database;
_application = application ?? new ApplicationConfig(10, false);
_groups = groups;
_tags = tags;
}
/// <summary>
/// Validates the config gor Host, Database, Username and Port
/// </summary>
protected static bool CheckDatabaseConfig(IDatabaseConfig config)
{
return(!(string.IsNullOrWhiteSpace(config.Host) ||
string.IsNullOrWhiteSpace(config.Database) ||
string.IsNullOrWhiteSpace(config.Username) ||
config.Port <= 0));
}
/// <inheritdoc />
public DbContext CreateContext(IDatabaseConfig config, ContextMode mode)
{
var context = (DbContext)Activator.CreateInstance(_contextType, BuildConnectionString(config));
context.SetContextMode(mode);
return(context);
}
/// <inheritdoc />
public IEnumerable <DatabaseUpdateInformation> AvailableMigrations(IDatabaseConfig config)
{
return(_migrations.Select(migration => new DatabaseUpdateInformation
{
Name = migration
}));
}
/// <inheritdoc />
public IEnumerable <DatabaseUpdateInformation> AppliedMigrations(IDatabaseConfig config)
{
return(GetInstalledMigrations(config).Select(migration => new DatabaseUpdateInformation
{
Name = migration
}));
}
public EventsDbService(IDatabaseConfig settings)
{
var client = new MongoClient(settings.ConnectionString);
var database = client.GetDatabase(settings.DatabaseName);
_events = database.GetCollection <Event>(settings.EventsCollectionName);
}
/// <inheritdoc />
public virtual bool CreateDatabase(IDatabaseConfig config)
{
// Check is database is configured
if (!CheckDatabaseConfig(config))
{
return(false);
}
using (var context = CreateContext(config, ContextMode.AllOff))
{
// Check if this database is present on the server
var dbExists = context.Database.Exists();
if (dbExists)
{
return(false);
}
context.Database.Create();
// Create connection to our new database
var connection = CreateConnection(config);
connection.Open();
// Creation done -> close connection
connection.Close();
return(true);
}
}
public EmailNotificationsDbService(IDatabaseConfig settings)
{
var client = new MongoClient(settings.ConnectionString);
var database = client.GetDatabase(settings.DatabaseName);
_emailNotifications = database.GetCollection <NotificationModel>(settings.EmailNotificationCollectionName);
}
public TenantDbService(IDatabaseConfig settings)
{
var client = new MongoClient(settings.ConnectionString);
var database = client.GetDatabase(settings.DatabaseName);
_tenants = database.GetCollection <TenantModel>(settings.TenantCollectionName);
}
public ParticipantsDbService(IDatabaseConfig settings)
{
var client = new MongoClient(settings.ConnectionString);
var database = client.GetDatabase(settings.DatabaseName);
_participants = database.GetCollection <Participants>(settings.ParticipantsCollectionName);
}
/// <inheritdoc />
public void Execute(IDatabaseConfig config, IModelSetup setup, string setupData)
{
var unitOfWorkFactory = new UnitOfWorkFactory <TContext>(_dbContextManager);
using (var uow = unitOfWorkFactory.Create(config))
setup.Execute(uow, setupData);
}
public InfluxDbAgent(IDatabaseConfig databaseConfig)
{
_databaseConfig = databaseConfig;
Uri result;
if (!Uri.TryCreate(_databaseConfig.Url, UriKind.Absolute, out result))
{
var exp = new InvalidOperationException("Unable to parse provided connection as url.");
exp.Data.Add("Url", databaseConfig.Url);
throw exp;
}
try
{
_influxDb = new InfluxDb(_databaseConfig.Url, _databaseConfig.Username, _databaseConfig.Password, InfluxVersion.Auto);
}
catch (Exception exception)
{
var exp = new InvalidOperationException("Could not establish a connection to the database.", exception);
exp.Data.Add("Url", databaseConfig.Url);
exp.Data.Add("Username", databaseConfig.Username);
throw exp;
}
}
public DatabaseMongoClient(IDatabaseConfig databaseConfig)
{
MongoClient = new MongoClient(new MongoClientSettings
{
Credential = MongoCredential.CreateCredential(databaseConfig.Name, databaseConfig.Username, databaseConfig.Password),
Server = new MongoServerAddress(databaseConfig.Host, databaseConfig.Port)
});
}
public UnitOfWork(IDatabaseConfig databaseConfig)
{
var connectionFactory = databaseConfig.GetConnectionFactory();
_connection = connectionFactory();
_connection.Open();
_transaction = _connection.BeginTransaction();
}
public void Dispose()
{
_config = null;
_connection.Close();
_connection.Dispose();
_connection = null;
}
public TestResultMongodbDAO(IDatabaseConfig config)
{
_config = config;
var clientSettings = MongoClientSettings.FromUrl(new MongoUrl(config.String));
_mongoClient = new MongoClient(clientSettings);
}
public CoreStore(IDatabaseConfig databaseConfig)
{
if (databaseConfig == null)
{
throw new NotImplementedException(nameof(databaseConfig));
}
this.mongoService = MongoService.GetService(databaseConfig.RestaurantConnectionString);
}
public void AddConfiguration(string name, Configuration configuration, IDatabaseConfig dbConfig)
{
if (_configurations.ContainsKey(name))
{
return;
}
_configurations.Add(name, new EnvironmentConfiguration(name, configuration, dbConfig));
}
public InfluxDataSender(IInfluxDbAgentLoader influxDbAgentLoader, IDatabaseConfig databaseConfig, int maxQueueSize)
{
_databaseConfig = databaseConfig;
_maxQueueSize = maxQueueSize;
_maxSendBatchCount = 1000;
_dropOnFail = false;
_client = new Lazy <IInfluxDbAgent>(() => influxDbAgentLoader.GetAgent(databaseConfig));
}
public InfluxDataSender(IInfluxDbAgentLoader influxDbAgentLoader, IDatabaseConfig databaseConfig, int maxQueueSize)
{
_databaseConfig = databaseConfig;
_maxQueueSize = maxQueueSize;
_maxSendBatchCount = 1000;
_dropOnFail = false;
_client = new Lazy<IInfluxDbAgent>(() => influxDbAgentLoader.GetAgent(databaseConfig));
}
internal DataMigrationMysqlDAO(IDatabaseConfig config)
{
_config = config;
_connection = new MySqlConnection(config.AdminString);
OpenConnection(_connection.Open);
CreateDatabase();
CreateSchemaVersion();
}
public IInfluxDbAgent GetAgent(IDatabaseConfig database)
{
if (database == null)
{
return(null);
}
return(new InfluxDbAgent(database.Url, database.Name, database.Username, database.Password, database.RequestTimeout));
}
public KafkaDataSender(IDatabaseConfig databaseConfig, int maxQueueSize)
{
var kafkaServers = databaseConfig.Url.Split(';').Select(x => new Uri(x)).ToArray();
_agent = new KafkaAgent(kafkaServers);
_databaseConfig = databaseConfig;
_maxQueueSize = maxQueueSize;
_dropOnFail = false;
}
private static IDatabaseConfig UpdateConfigFromModel(IDatabaseConfig dbConfig, DatabaseConfigModel model)
{
dbConfig.Host = model.Server;
dbConfig.Port = model.Port;
dbConfig.Database = model.Database;
dbConfig.Username = model.User;
dbConfig.Password = model.Password;
return(dbConfig);
}
private static DbMigrationsModel[] GetInstalledUpdates(IDatabaseConfig dbConfig, IModelConfigurator configurator)
{
var appliedMigrations = configurator.AppliedMigrations(dbConfig).ToList();
return(appliedMigrations.Select(u => new DbMigrationsModel
{
Name = u.Name
}).ToArray());
}
internal DataMigrationMongodbDAO(IDatabaseConfig config)
{
var clientSettings = MongoClientSettings.FromUrl(new MongoUrl(config.AdminString));
_mongoClient = new MongoClient(clientSettings);
_config = config;
OpenConnection(new Action(() => { GetCurrentVersion(); }));
}
public KafkaDataSender(IDatabaseConfig databaseConfig, int maxQueueSize)
{
var kafkaServers = databaseConfig.Url.Split(';').Select(x => new Uri(x)).ToArray();
_agent = new KafkaAgent(kafkaServers);
_databaseConfig = databaseConfig;
_maxQueueSize = maxQueueSize;
_dropOnFail = false;
}
public IInfluxDbAgent GetAgent(IDatabaseConfig database)
{
if (database == null)
{
return null;
}
return new InfluxDbAgent(database);
}
/// <summary>
/// Initializes a new instance of the <see cref="NhibernateHelper"/> class.
/// </summary>
/// <param name="config">Configuration dependacy injection</param>
public NhibernateHelper(IDatabaseConfig config)
{
if (config == null)
{
throw new NullReferenceException("IDatabaseConfig");
}
this.config = config;
}
public IInfluxDbAgent GetAgent(IDatabaseConfig database)
{
if (database == null)
{
return null;
}
return new InfluxDbAgent(database.Url, database.Name, database.Username, database.Password);
}
public VendaRepository(IDatabaseConfig config)
{
DapperNodaTimeSetup.Register();
_action = config.DbAction;
_itemVendaDataAccess = new ItemVendaDataAccess();
_tableVenda = DatabaseUtils.Table <Venda>();
_tableItemVenda = DatabaseUtils.Table <ItemVenda>();
_tableDisco = DatabaseUtils.Table <Disco>();
}
public IInfluxDbAgent GetAgent(IDatabaseConfig database)
{
if (database == null)
{
return(null);
}
return(new InfluxDbAgent(database));
}
private static DbMigrationsModel[] GetAvailableUpdates(IDatabaseConfig dbConfig, IModelConfigurator configurator)
{
var availableMigrations = configurator.AvailableMigrations(dbConfig).ToList();
return(availableMigrations.Select(u => new DbMigrationsModel
{
Name = u.Name
}).ToArray());
}
private IMigrationProcessorFactory GetMigrationProcessorFactory(IDatabaseConfig databaseConfig)
{
string processorName;
var vendor = databaseConfig.Vendor;
if (!DatabaseProcessorMapping.TryGetValue(vendor.ToUpper(), out processorName))
{
throw new Exception(string.Format("The vendor '{0}' processor type has not been set up for Habanero Test Migrations.", vendor));
}
var migrationProcessorFactoryProvider = new MigrationProcessorFactoryProvider();
return migrationProcessorFactoryProvider.GetFactory(processorName);
}
public void GetEnvironmentConfiguration()
{
_fakeDbConfig = Isolate.Fake.Instance<IDatabaseConfig>();
var fakeConn = Isolate.Fake.Instance<IDbConnection>();
Isolate.WhenCalled(() => _fakeDbConfig.GetConnection()).WillReturn(fakeConn);
var fakeConfig = Isolate.Fake.Instance<Configuration>();
Isolate.WhenCalled(() => fakeConfig.BuildSessionFactory()).ReturnRecursiveFake();
_envConfig = new EnvironmentConfiguration(TestEnv, fakeConfig, _fakeDbConfig);
Isolate.WhenCalled(() => _envConfig.BuildSchema(fakeConn)).WithExactArguments().IgnoreCall();
}
public InfluxDbAgent(IDatabaseConfig databaseConfig)
{
_databaseConfig = databaseConfig;
Uri result;
if (!Uri.TryCreate(_databaseConfig.Url, UriKind.Absolute, out result))
{
var exp = new InvalidOperationException("Unable to parse provided connection as url.");
exp.Data.Add("Url", databaseConfig.Url);
throw exp;
}
try
{
_influxDb = new InfluxDb(_databaseConfig.Url, _databaseConfig.Username, _databaseConfig.Password, InfluxVersion.Auto);
}
catch (Exception exception)
{
var exp = new InvalidOperationException("Could not establish a connection to the database.", exception);
exp.Data.Add("Url", databaseConfig.Url);
exp.Data.Add("Username", databaseConfig.Username);
throw exp;
}
}
/// <summary>
/// Creates a new database connection with the configuration
/// provided
/// </summary>
/// <param name="config">The database access configuration</param>
/// <returns>Returns a new database connection</returns>
public IDatabaseConnection CreateConnection(IDatabaseConfig config)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
if (string.Compare(config.Vendor, DatabaseConfig.MySql, true) == 0)
{
return String.IsNullOrEmpty(config.AssemblyName)
? new DatabaseConnectionMySql("MySql.Data", "MySql.Data.MySqlClient.MySqlConnection", config.GetConnectionString())
: new DatabaseConnectionMySql(config.AssemblyName, config.FullClassName, config.GetConnectionString());
}
if (string.Compare(config.Vendor, DatabaseConfig.SqlServer, true) == 0)
{
return String.IsNullOrEmpty(config.AssemblyName)
? new DatabaseConnectionSqlServer("System.Data", "System.Data.SqlClient.SqlConnection", config.GetConnectionString())
: new DatabaseConnectionSqlServer(config.AssemblyName, config.FullClassName, config.GetConnectionString());
}
if (string.Compare(config.Vendor, DatabaseConfig.SqlServerCe, true) == 0)
{
return String.IsNullOrEmpty(config.AssemblyName)
? new DatabaseConnectionSqlServerCe("System.Data.SqlServerCe", "System.Data.SqlServerCe.SqlCeConnection", config.GetConnectionString())
: new DatabaseConnectionSqlServerCe(config.AssemblyName, config.FullClassName, config.GetConnectionString());
}
if (string.Compare(config.Vendor, DatabaseConfig.Oracle, true) == 0)
{
return String.IsNullOrEmpty(config.AssemblyName)
? new DatabaseConnectionOracle("System.Data.OracleClient, Version=2.0.0.0, Culture=neutral,PublicKeyToken=b77a5c561934e089", "System.Data.OracleClient.OracleConnection",
config.GetConnectionString())
: new DatabaseConnectionOracle(config.AssemblyName, config.FullClassName, config.GetConnectionString());
}
if (string.Compare(config.Vendor, DatabaseConfig.Access, true) == 0)
{
return String.IsNullOrEmpty(config.AssemblyName)
? new DatabaseConnectionAccess("System.Data", "System.Data.OleDb.OleDbConnection", config.GetConnectionString())
: new DatabaseConnectionAccess(config.AssemblyName, config.FullClassName, config.GetConnectionString());
}
if (string.Compare(config.Vendor, DatabaseConfig.PostgreSql, true) == 0)
{
return String.IsNullOrEmpty(config.AssemblyName)
? new DatabaseConnectionPostgreSql("Npgsql", "Npgsql.NpgsqlConnection", config.GetConnectionString())
: new DatabaseConnectionPostgreSql(config.AssemblyName, config.FullClassName, config.GetConnectionString());
}
if (string.Compare(config.Vendor, DatabaseConfig.SQLite, true) == 0)
{
return String.IsNullOrEmpty(config.AssemblyName)
? new DatabaseConnectionSQLite("System.Data.SQLite", "System.Data.SQLite.SQLiteConnection", config.GetConnectionString())
: new DatabaseConnectionSQLite(config.AssemblyName, config.FullClassName, config.GetConnectionString());
}
if (string.Compare(config.Vendor, DatabaseConfig.Firebird, true) == 0)
{
return String.IsNullOrEmpty(config.AssemblyName)
? new DatabaseConnectionFirebird("FirebirdSql.Data.FirebirdClient", "FirebirdSql.Data.FirebirdClient.FbConnection",
config.GetConnectionString())
: new DatabaseConnectionFirebird(config.AssemblyName, config.FullClassName, config.GetConnectionString());
}
if (string.Compare(config.Vendor, DatabaseConfig.FirebirdEmbedded, true) == 0)
{
return String.IsNullOrEmpty(config.AssemblyName)
? new DatabaseConnectionFirebird("FirebirdSql.Data.FirebirdClient", "FirebirdSql.Data.FirebirdClient.FbConnection",
config.GetConnectionString())
: new DatabaseConnectionFirebird(config.AssemblyName, config.FullClassName, config.GetConnectionString());
}
if (string.Compare(config.Vendor, DatabaseConfig.Access2007, true) == 0)
{
return String.IsNullOrEmpty(config.AssemblyName)
? new DatabaseConnectionAccess2007("System.Data", "System.Data.OleDb.OleDbConnection",
config.GetConnectionString())
: new DatabaseConnectionAccess2007(config.AssemblyName, config.FullClassName, config.GetConnectionString());
}
return null;
}
protected async Task<IDatabaseConfig> GetUsernameAsync(string paramList, int index, IDatabaseConfig config, string action)
{
var dataChanged = false;
var url = config.Url;
IInfluxDbAgent client = null;
InfluxDbApiResponse response = null;
try
{
if (!string.IsNullOrEmpty(config.Name) && !string.IsNullOrEmpty(config.Username) && !string.IsNullOrEmpty(config.Password))
{
client = _influxDbAgentLoader.GetAgent(config);
response = await MetaDataBusiness.TestWriteAccess(client, action);
}
}
catch (Exception exception)
{
OutputError(exception.Message);
}
if (response == null || !response.Success)
OutputInformation("Enter the database, username and password for the InfluxDB.");
while (response == null || !response.Success)
{
var database = string.Empty;
try
{
database = QueryParam<string>("DatabaseName", GetParam(paramList, index++));
var user = QueryParam<string>("Username", GetParam(paramList, index++));
var password = QueryParam<string>("Password", GetParam(paramList, index++));
config = new InfluxDatabaseConfig(url, user, password, database);
client = _influxDbAgentLoader.GetAgent(config);
response = await MetaDataBusiness.TestWriteAccess(client, action);
dataChanged = true;
}
catch (CommandEscapeException)
{
return null;
}
catch (InfluxDbApiException exception)
{
if (exception.StatusCode == HttpStatusCode.NotFound)
{
var create = QueryParam("Database does not exist, create?", GetParam(paramList, index++), new Dictionary<bool, string>() { { true, "Yes" }, { false, "No" } });
if (create)
{
client.CreateDatabaseAsync(database);
response = MetaDataBusiness.TestWriteAccess(client, action).Result;
dataChanged = true;
}
}
}
catch (Exception exception)
{
OutputError("{0}", exception.Message);
}
}
OutputInformation("Access to database {0} confirmed.", config.Name);
if (dataChanged)
_configBusiness.SaveDatabaseConfig(config.Name, config.Username, config.Password);
return config;
}
public VTable_Offer_Details(IDatabaseConfig _DBConfig)
: base(VTableName, false)
{
Setup(VTableName, _DBConfig, true);
}
public VTable_LandAgents(IDatabaseConfig _DBConfig)
: base(VTableName, false)
{
Setup(VTableName, _DBConfig, true);
}
/// <summary>
/// Sets up the database connection. If not provided, then
/// reads the connection from the config file.
/// </summary>
protected override void SetupDatabaseConnection()
{
if (DatabaseConnection.CurrentConnection != null) return;
if (_databaseConfig == null) _databaseConfig = Habanero.DB.DatabaseConfig.ReadFromConfigFile();
if (_databaseConfig.IsInMemoryDB())
{
BORegistry.DataAccessor = new DataAccessorInMemory();
}
else
{
ISupportsRSADecryption encryptedDatabaseConfig = _databaseConfig as ISupportsRSADecryption;
if (_privateKey != null && encryptedDatabaseConfig != null) encryptedDatabaseConfig.SetPrivateKeyFromXML(_privateKey);
DatabaseConnection.CurrentConnection = _databaseConfig.GetDatabaseConnection();
BORegistry.DataAccessor = new DataAccessorDB();
}
}
public const string VTableName = "[Greensheet Additional Details]"; // GSMOREDETAIL
#endregion Fields
#region Constructors
public VTable_Greensheet_AdditionalDetails(IDatabaseConfig _DBConfig)
: base(VTableName, false)
{
Setup(VTableName, _DBConfig, true);
}
public IInfluxDbAgent GetAgent(IDatabaseConfig database)
{
if (database == null) throw new ArgumentNullException("database", "No database configuration provided.");
return new InfluxDbAgent(database);
}
public VTable_Towns(IDatabaseConfig _DBConfig)
: base(VTableName, false)
{
Setup(VTableName, _DBConfig, true);
}
/// <summary>
/// Define datatable structure.
/// </summary>
/// <param name="SqlTableName"></param>
/// <param name="aDatabaseConfig"></param>
/// <param name="bEnableFieldDelimiter"></param>
public void Setup(string SqlTableName, IDatabaseConfig aDatabaseConfig, bool bEnableFieldDelimiter)
{
_SQLTableName = SqlTableName;
_DatabaseConfig = aDatabaseConfig;
_DBConn = _DatabaseConfig.GetHandler().getDataConnection();
_EnableFieldDelimiter = bEnableFieldDelimiter;
_BeginDelimiterChar = aDatabaseConfig.GetHandler().getFieldBeginDelimiter();
_EndDelimiterChar = aDatabaseConfig.GetHandler().getFieldEndDelimiter();
if (_EnableVC)
{
_ADP = _DatabaseConfig.GetHandler().getDataAdapter("Select " + GetSQLFields() + " from " + _SQLTableName + " where VC_State = 'Approved'", _DBConn);
}
else
{
_ADP = _DatabaseConfig.GetHandler().getDataAdapter("Select " + GetSQLFields() + " from " + _SQLTableName, _DBConn);
}
//new SqlDataAdapter("Select "+ GetSQLFields() +" from "+_SQLTableName+" where VC_State = 'Approved'", _DBConn);
// Create Own Update, insert and Delete commands
//_Builder = new SqlCommandBuilder(_ADP);
// replace the update command
_ADP.UpdateCommand = BuildUpdate(_DBConn);
_ADP.DeleteCommand = BuildDelete(_DBConn);
_ADP.InsertCommand = BuildInsert(_DBConn);
}
public EventStorage(IEventSerializer serializer, IDatabaseConfig dbConfig)
{
_serializer = serializer;
_dbConfig = dbConfig;
}
public SendBusinessEventArgs(IDatabaseConfig databaseConfig, Exception exception)
{
_databaseConfig = databaseConfig;
_exception = exception;
_outputLevel = OutputLevel.Error;
}
public const string VTableName = "[GreensheetData]"; // GSDATA
#endregion Fields
#region Constructors
public VTable_Greensheet_Data(IDatabaseConfig _DBConfig)
: base(VTableName, false)
{
Setup(VTableName, _DBConfig, true);
}
public const string VTableName = "[Contacts List - Main]"; // CONTACTSFROMOUTLOOK
#endregion Fields
#region Constructors
public VTable_ContactsMain(IDatabaseConfig _DBConfig)
: base(VTableName, false)
{
Setup(VTableName, _DBConfig, true);
}
public const string VTableName = "[Developer County Requirements]"; // DEVREQ
#endregion Fields
#region Constructors
public VTable_DeveloperCountyRequirements(IDatabaseConfig _DBConfig)
: base(VTableName, false)
{
Setup(VTableName, _DBConfig, true);
}
public EnvironmentConfiguration(string testEnv, Configuration config, IDatabaseConfig dbConfig)
{
_databaseConfig = dbConfig;
_configuration = config;
EnvironmentName = testEnv;
}
protected async Task<IDatabaseConfig> GetUsernameAsync(string paramList, int index, IDatabaseConfig config, string action)
{
var points = new[]
{
new Point
{
Name = Constants.ServiceName,
Tags = new Dictionary<string, string>
{
{ "hostname", Environment.MachineName },
{ "version", Assembly.GetExecutingAssembly().GetName().Version.ToString() },
{ "action", action },
},
Fields = new Dictionary<string, object>
{
{ "value", 1 }
},
Precision = TimeUnit.Microseconds,
Timestamp = DateTime.UtcNow
},
};
var dataChanged = false;
var url = config.Url;
IInfluxDbAgent client = null;
InfluxDbApiResponse response = null;
try
{
if (!string.IsNullOrEmpty(config.Name) && !string.IsNullOrEmpty(config.Username) && !string.IsNullOrEmpty(config.Password))
{
client = _influxDbAgentLoader.GetAgent(config);
response = await client.WriteAsync(points);
}
}
catch (Exception exception)
{
OutputError(exception.Message);
}
if (response == null || !response.Success)
OutputInformation("Enter the database, username and password for the InfluxDB.");
while (response == null || !response.Success)
{
var database = string.Empty;
try
{
database = QueryParam<string>("DatabaseName", GetParam(paramList, index++));
var user = QueryParam<string>("Username", GetParam(paramList, index++));
var password = QueryParam<string>("Password", GetParam(paramList, index++));
config = new DatabaseConfig(url, user, password, database);
client = _influxDbAgentLoader.GetAgent(config);
response = await client.WriteAsync(points);
dataChanged = true;
}
catch (CommandEscapeException)
{
return null;
}
catch (InfluxDbApiException exception)
{
if (exception.StatusCode == HttpStatusCode.NotFound)
{
var create = QueryParam("Database does not exist, create?", GetParam(paramList, index++), new Dictionary<bool, string>() { { true, "Yes" }, { false, "No" } });
if (create)
{
client.CreateDatabaseAsync(database);
response = client.WriteAsync(points).Result;
dataChanged = true;
}
}
}
catch (Exception exception)
{
OutputError("{0}", exception.Message);
}
}
OutputInformation("Access to database {0} confirmed.", config.Name);
if (dataChanged)
_configBusiness.SaveDatabaseConfig(config.Name, config.Username, config.Password);
return config;
}
public EnvironmentConfiguration(string name, Configuration config, IDatabaseConfig dbConfig)
{
_databaseConfig = dbConfig;
_configuration = config;
EnvironmentName = name;
}
public SendBusinessEventArgs(IDatabaseConfig databaseConfig, string message, int count, OutputLevel outputLevel)
{
_databaseConfig = databaseConfig;
_message = message;
_outputLevel = outputLevel;
}
public static VTable_Base Select(string tablename, IDbCommand aSelectCommand, IDatabaseConfig _DatabaseConfig)
{
VTable_Base tmp = new VTable_Base(tablename, false);
IDbDataAdapter aDp = _DatabaseConfig.GetHandler().getDataAdapter(aSelectCommand);
try
{
aDp.SelectCommand.Connection.Close();
aDp.SelectCommand.Connection.Open();
// aDp.Fill(tmp.Table);
// aDp.SelectCommand.Connection.Close();
if (aDp is MySql.Data.MySqlClient.MySqlDataAdapter)
((MySql.Data.MySqlClient.MySqlDataAdapter)aDp).Fill(tmp.Table);
if (aDp is System.Data.SqlClient.SqlDataAdapter)
((System.Data.SqlClient.SqlDataAdapter)aDp).Fill(tmp.Table);
if (aDp is System.Data.OleDb.OleDbDataAdapter)
((System.Data.OleDb.OleDbDataAdapter)aDp).Fill(tmp.Table);
}
catch (Exception Ex)
{
Logger.LogWriter.Write(Ex.Message);
}
finally
{
aDp.SelectCommand.Connection.Close();
}
return tmp;
}
public const string VTableName = "[Contacts - Organisations]"; // CONTACTORG
#endregion Fields
#region Constructors
public VTable_ContactsOrganisations(IDatabaseConfig _DBConfig)
: base(VTableName, false)
{
Setup(VTableName, _DBConfig, true);
}
public VTable_Affiliates(IDatabaseConfig _DBConfig)
: base(VTableName, false)
{
Setup(VTableName, _DBConfig, true);
}
