public override bool Initialize(DBConnectionInfo info)
{
sqlInfo = new MySQLInfo();
sqlInfo.Connect(info.user, info.password, info.databaseName, info.IP, info.port);
return(true);
}
public void AssertNumOfOpenDBConnection(string testName, DBConnectionInfo dbConnectionInfo, NumOfDBConnections numOfOpenConnections_Before)
{
NumOfDBConnections numOfOpenConnections_After = _dbHandler.GetNumOfOpenConnection(dbConnectionInfo);
Assert.That(numOfOpenConnections_Before.NumOfConnectionsToDB, Is.GreaterThanOrEqualTo(numOfOpenConnections_After.NumOfConnectionsToDB), $"{testName} >>> NumOfConnectionsToDB after '{numOfOpenConnections_After.NumOfConnectionsToDB}', is grater then before '{numOfOpenConnections_Before.NumOfConnectionsToDB}'");
Assert.That(numOfOpenConnections_Before.NumOfConnectionsToAdminDB, Is.GreaterThanOrEqualTo(numOfOpenConnections_After.NumOfConnectionsToAdminDB), $"{testName} >>> NumOfConnectionsToAdminDB after '{numOfOpenConnections_After.NumOfConnectionsToAdminDB}', is grater then before '{numOfOpenConnections_Before.NumOfConnectionsToAdminDB}'");
}
public DataTable GetTable(DBConnectionInfo dbConnectionInfo, string tableName)
{
using (var dbCommands = _dbCommandsFactory.CreateDBCommand(dbConnectionInfo))
{
return(dbCommands.GetTable(tableName));
}
}
public List <ReportUIInit> InitReportWindow(DBConnectionInfo dbServerDetails)
{
List <ReportUIInit> result = null;
ReportOperation reportOperation = null;
try
{
if (dbServerDetails.DatabaseType == EnumHelper.Databases.SQLServer)
{
reportOperation = new SQlReportOperation();
}
else if (dbServerDetails.DatabaseType == EnumHelper.Databases.SQLServerCE)
{
reportOperation = new SQlCEReportOperation();
}
result = reportOperation.InitReportWindow(dbServerDetails);
}
catch (Exception ex)
{
AMTLogger.WriteToLog(ex.Message, MethodBase.GetCurrentMethod().Name, 0, AMTLogger.LogInfo.Error);
}
return(result);
}
public static DBConnectionInfo LoadDbConnectionInfo()
{
DBConnectionInfo connectioninfo = new DBConnectionInfo();
try
{
DBProfileInfo dbProfileInfo = new DBProfileInfo();
if (File.Exists(ApplicationInfo.DBProfileName))
{
XMLSerializer <DBProfileInfo> .DeSerializeInputs <DBProfileInfo>(ApplicationInfo.DBProfileName, ref dbProfileInfo);
connectioninfo.AuthenticationType = dbProfileInfo.AuthenticationType;
connectioninfo.DatabaseName = ApplicationInfo.DatabaseName;
connectioninfo.DatabaseType = dbProfileInfo.DatabaseType;
connectioninfo.DBPath = ApplicationInfo.ApplicationDocumentPath;
connectioninfo.Password = dbProfileInfo.Password;
connectioninfo.UserName = dbProfileInfo.UserName;
connectioninfo.ServerName = dbProfileInfo.ServerName;
}
}
catch (Exception ex)
{
AMTLogger.WriteToLog(ex.Message, MethodBase.GetCurrentMethod().Name, 0, AMTLogger.LogInfo.Error);
}
return(connectioninfo);
}
public Boolean CheckDatabaseConnectvity(DBConnectionInfo dbServerDetails)
{
Boolean result = false;
IDatabaseCreate databaseCreate = null;
try
{
if (dbServerDetails.DatabaseType == EnumHelper.Databases.SQLServer)
{
databaseCreate = new SQLDBCreation();
}
else if (dbServerDetails.DatabaseType == EnumHelper.Databases.SQLServerCE)
{
databaseCreate = new SqlCeDBCreation();
}
result = databaseCreate.CheckDatabaseConnection(dbServerDetails);
}
catch (Exception ex)
{
AMTLogger.WriteToLog(ex.Message, MethodBase.GetCurrentMethod().Name, 0, AMTLogger.LogInfo.Error);
}
return(result);
}
public bool CreateApplicationDatabase(DBConnectionInfo ConnectionDetails)
{
Boolean result = false;
try
{
this.DatabaseConnectionDetails = ConnectionDetails;
if (DatabaseConnect())
{
if (CreateDatabase())
{
CreateTables();
}
CleanNetWorkList();
DoSupportiveOperations();
DatabaseDisConnect();
}
}
catch (Exception ex)
{
AMTLogger.WriteToLog(ex.Message, MethodBase.GetCurrentMethod().Name, 0, AMTLogger.LogInfo.Error);
}
return(result);
}
public BaseTripController(DBConnectionInfo dBConnectionInfo)
{
Ctx = new mydrivingDBContext(dBConnectionInfo);
//Select Random Trip
GetSampleTrip();
//Default Constructor
}
private static string CreateConnecntionStringByDBName(DBConnectionInfo dbConnectionInfo, string dbName)
{
SqlConnectionStringBuilder connectionStringBuilder = new SqlConnectionStringBuilder
{
InitialCatalog = dbName
};
if (string.IsNullOrWhiteSpace(dbConnectionInfo.Server))
{
connectionStringBuilder.DataSource = "(local)";
}
else
{
connectionStringBuilder.DataSource = dbConnectionInfo.Server;
}
if (!string.IsNullOrWhiteSpace(dbConnectionInfo.Username))
{
connectionStringBuilder.UserID = dbConnectionInfo.Username;
connectionStringBuilder.Password = dbConnectionInfo.Password;
}
else
{
connectionStringBuilder.IntegratedSecurity = true;
}
return(connectionStringBuilder.ConnectionString);
}
public BOBase()
{
DBConnectionInfo context = Yqun.Common.ContextCache.ServerLoginInfos.DBConnectionInfo;
string DataAdapterType = context.DataAdapterType;
string DataBaseType = context.DataBaseType;
string DataSource = context.DataSource;
string DataInstance = context.DataInstance;
string DataUserName = context.DataUserName;
string DataPassword = context.DataPassword;
bool DataISAttach = false;
bool.TryParse(context.DataISAttach, out DataISAttach);
bool DataIntegratedLogin = false;
//DataAdapterType = "sqlclient";
//DataBaseType = "mssqlserver2k5";
//DataSource = @".\SQLEXPRESS";
//DataInstance = "testDB";
//DataUserName = "******";
//DataPassword = "******";
//DataISAttach = false;
//DataIntegratedLogin = false;
bool.TryParse(context.DataIntegratedLogin, out DataIntegratedLogin);
string DataAppRoot = context.LocalStartPath;
CreateInstance(DataAdapterType, DataBaseType, DataIntegratedLogin, DataSource, DataInstance, DataUserName, DataPassword, DataISAttach, DataAppRoot);
}
public bool CheckIfTableExist(DBConnectionInfo dbConnectionInfo, string schemaName, string tableName)
{
using (var dbCommands = _dbCommandsFactory.CreateDBCommand(dbConnectionInfo))
{
return(dbCommands.CheckIfTableExist(schemaName, tableName));
}
}
public DataTable GetAllDBSchemaExceptDBVersionSchema(DBConnectionInfo dbConnectionInfo)
{
using (var dbCommands = _dbCommandsFactory.CreateDBCommand(dbConnectionInfo))
{
return(dbCommands.GetAllDBSchemaExceptDBVersionSchema());
}
}
private Boolean ShowDBSettings()
{
Boolean result = false;
try
{
if (!IsDatabaseConfigured())
{
SettingsManager settingsManager = new SettingsManager();
if (settingsManager.ShowDialog() == DialogResult.OK)
{
dbConnectionInfo = Utility.LoadDbConnectionInfo();
result = true;
}
}
else
{
dbConnectionInfo = Utility.LoadDbConnectionInfo();
}
}
catch (Exception ex)
{
AMTLogger.WriteToLog(ex.Message, MethodBase.GetCurrentMethod().Name, 0, AMTLogger.LogInfo.Error);
}
return(result);
}
public bool CheckIfStoredProcedureExist(DBConnectionInfo dbConnectionInfo, string schemaName, string spName)
{
using (var dbCommands = _dbCommandsFactory.CreateDBCommand(dbConnectionInfo))
{
return(dbCommands.CheckIfStoredProcedureExist(schemaName, spName));
}
}
public NumOfDBConnections GetNumOfOpenConnection(DBConnectionInfo dbConnectionInfo)
{
NumOfDBConnections numOfConnectionsItem = new NumOfDBConnections();
string masterDBName;
using (var dbCommands = _dbCommandsFactory.CreateDBCommand(dbConnectionInfo))
{
masterDBName = dbCommands.DataBaseName;
}
using (var dbCommands = _dbCommandsFactory.CreateDBCommand(dbConnectionInfo))
{
numOfConnectionsItem.DBName = dbCommands.DataBaseName;
}
using (var dbQueryStatus = _dbCommandsFactory.CreateDBQueryStatus(dbConnectionInfo))
{
numOfConnectionsItem.NumOfConnectionsToDB = dbQueryStatus.GetNumOfOpenConnection(numOfConnectionsItem.DBName);
numOfConnectionsItem.NumOfConnectionsToAdminDB = dbQueryStatus.GetNumOfOpenConnection(masterDBName);
}
return(numOfConnectionsItem);
}
public void AssertDBInFinalState_OnlyIncremental(string testName, DBConnectionInfo dbConnectionInfo)
{
AssertTable1ExistWithFullData(testName, dbConnectionInfo);
string tableName = "[Schema2].[LookupTable1]";
AssertTableExsit(testName, dbConnectionInfo, "Schema2", "LookupTable1");
DataTable tableData = _dbHandler.GetTable(dbConnectionInfo, tableName);
AssertTableNumOfRows(testName, tableName, tableData, 0);
tableName = "[Schema2].[LookupTable2]";
AssertTableExsit(testName, dbConnectionInfo, "Schema2", "LookupTable2");
tableData = _dbHandler.GetTable(dbConnectionInfo, tableName);
AssertTableNumOfRows(testName, tableName, tableData, 0);
tableName = "[Schema3].[InvoiceTable1]";
AssertTableExsit(testName, dbConnectionInfo, "Schema3", "InvoiceTable1");
tableData = _dbHandler.GetTable(dbConnectionInfo, tableName);
AssertTableNumOfRows(testName, tableName, tableData, 0);
tableName = "[Schema3].[TransTable1]";
AssertTableExsit(testName, dbConnectionInfo, "Schema3", "TransTable1");
tableData = _dbHandler.GetTable(dbConnectionInfo, tableName);
AssertTableNumOfRows(testName, tableName, tableData, 0);
AssertSpExsit(testName, dbConnectionInfo, "Schema1", "SpOnTable1");
}
public IDBConnection CreateAdminDBConnection(DBConnectionInfo dbConnectionInfo)
{
dbConnectionInfo.ThrowIfNull(nameof(dbConnectionInfo));
SqlServerConnection sqlServerConnection = new SqlServerConnection(CreateAdminConnectionString(dbConnectionInfo), dbConnectionInfo.Timeout);
return(sqlServerConnection);
}
public SystemTablesValidator(DBCommandsFactory dbCommandsFactory,
bool isDevEnvironment,
DBConnectionInfo dbConnectionInfo)
{
_dbCommandsFactory = dbCommandsFactory;
_isDevEnvironment = isDevEnvironment;
_dbConnectionInfo = dbConnectionInfo;
}
public ApiTripController(DBConnectionInfo dBConnectionInfo, string apiEndPoint) : base(dBConnectionInfo)
{
endPoint = apiEndPoint;
tripStore = new TripStore(endPoint);
tripPointStore = new TripPointStore(endPoint);
poiStore = new PoiStore(endPoint);
userStore = new UserStore(endPoint);
}
/// <summary>
/// Creates an instance of the database facade using the provider and connection string passed.
/// </summary>
/// <exception cref="System.ArgumentNullException">
/// Thrown if connectionString is null or empty.
/// </exception>
/// <exception cref="OgreDA.DataAccess.DataAccessException">
/// Thrown when the providerName contains an unrecognized provider.
/// </exception>
/// <param name="providerName">The provider to use. Can be System.Data.SqlClient, System.Data.OleDb or
/// the invariant name of a DbProviderFactories setting in the config file.</param>
/// <param name="connectionString">The connection string to use.</param>
public Database(string providerName, string connectionString)
{
if (string.IsNullOrEmpty(connectionString))
{
throw new ArgumentNullException("connectionString cannot be null or empty.");
}
_connectionString = new DBConnectionInfo(connectionString, providerName);
providerFactory = setupProvider(_connectionString);
}
/// <summary>
/// Creates an instance of the database facade using the database connection information passed.
/// </summary>
/// <exception cref="System.ArgumentNullException">
/// Thrown if connectionString is null.
/// </exception>
/// <exception cref="OgreDA.DataAccess.DataAccessException">
/// Thrown when the connection contains an unrecognized provider.
/// </exception>
/// <param name="connectionString">Connection String to use to connect to the database.</param>
public Database(DBConnectionInfo connectionString)
{
if (connectionString == null || string.IsNullOrEmpty(connectionString.ConnectionString))
{
throw new ArgumentNullException("connectionString cannot be null or empty.");
}
_connectionString = connectionString;
providerFactory = setupProvider(connectionString);
}
public void AssertThatDBExecutedFilesAreInMiddleState(string testName, DBConnectionInfo dbConnectionInfo)
{
DataTable tableData = _dbHandler.GetTable(dbConnectionInfo, DBCommandsConsts.DBScriptsExecutionHistoryFilesFullTableName);
AssertTableNumOfRows(testName, DBCommandsConsts.DBScriptsExecutionHistoryFilesFullTableName, tableData, 3);
AssertTableCellValue(testName, DBCommandsConsts.DBScriptsExecutionHistoryFilesFullTableName, tableData, 0, "Filename", "incScript_0001_initState.sql");
AssertTableCellValue(testName, DBCommandsConsts.DBScriptsExecutionHistoryFilesFullTableName, tableData, 1, "Filename", "incScript_0002_CreateLookupTable1.sql");
AssertTableCellValue(testName, DBCommandsConsts.DBScriptsExecutionHistoryFilesFullTableName, tableData, 2, "Filename", "incScript_0003_CreateLookupTable2.sql");
}
public NewProjectValidator(DBCommandsFactory dbCommandsFactory,
bool isDevEnvironment,
DBConnectionInfo dbConnectionInfo,
ScriptFilesState scriptFilesState)
{
_dbCommandsFactory = dbCommandsFactory;
_isDevEnvironment = isDevEnvironment;
_dbConnectionInfo = dbConnectionInfo;
_scriptFilesState = scriptFilesState;
}
public ApiTripController(DBConnectionInfo dBConnectionInfo, string UserApiEndPoint, string PoiApiEndPoint, string TripsApiEndPoint) : base(dBConnectionInfo)
{
userApiEndPoint = UserApiEndPoint;
poiApiEndPoint = PoiApiEndPoint;
tripsApiEndPoint = TripsApiEndPoint;
tripStore = new TripStore(tripsApiEndPoint);
tripPointStore = new TripPointStore(tripsApiEndPoint);
poiStore = new PoiStore(poiApiEndPoint);
userStore = new UserStore(userApiEndPoint);
}
public void DropDB(DBConnectionInfo dbConnectionInfo)
{
using (var dbConnection = _dbCommandsFactory.CreateDBConnection(dbConnectionInfo))
{
using (var dbBackupRestoreCommands = _dbCommandsFactory.CreateDBBackupRestoreCommands(dbConnectionInfo))
{
dbBackupRestoreCommands.DropDB(dbConnectionInfo.DBName);
}
}
}
public void CreateDBBackup(DBConnectionInfo dbConnectionInfo, string targetFilePath)
{
using (var dbConnection = _dbCommandsFactory.CreateDBConnection(dbConnectionInfo))
{
using (var dbBackupRestoreCommands = _dbCommandsFactory.CreateDBBackupRestoreCommands(dbConnectionInfo))
{
dbBackupRestoreCommands.CreateDBBackup(targetFilePath, dbConnectionInfo.DBName);
}
}
}
public string GetScriptFullPath_DevDummyData_scriptName1(DBConnectionInfo dbConnectionInfo)
{
string devScriptsBaseFolderPath = FileSystemPathUtils.ParsePathVaribles(IntegrationTestsConsts.DevScriptsBaseFolderPath_Normal);
devScriptsBaseFolderPath = devScriptsBaseFolderPath.Replace("[DBType]", dbConnectionInfo.DBType);
string scriptFilename = $"dddScript_0003_{ScriptName1}.sql";
string script1FullPath = Path.Combine(devScriptsBaseFolderPath, _relFolder_DevDummyData, scriptFilename);
return(script1FullPath);
}
private void AssertTable1ExistWithFullData(string testName, DBConnectionInfo dbConnectionInfo)
{
string tableName = "[Schema1].[Table1]";
AssertTableExsit(testName, dbConnectionInfo, "Schema1", "Table1");
DataTable tableData = _dbHandler.GetTable(dbConnectionInfo, tableName);
AssertTableNumOfRows(testName, tableName, tableData, 2);
AssertTableCellValue(testName, tableName, tableData, 0, "Col1", "aa");
AssertTableCellValue(testName, tableName, tableData, 1, "Col1", "bb");
}
public string GetScriptFullPath_Incremental_scriptName2(DBConnectionInfo dbConnectionInfo)
{
string devScriptsBaseFolderPath = FileSystemPathUtils.ParsePathVaribles(IntegrationTestsConsts.DevScriptsBaseFolderPath_Normal);
devScriptsBaseFolderPath = devScriptsBaseFolderPath.Replace("[DBType]", dbConnectionInfo.DBType);
string scriptFilename = $"incScript_0007_{ScriptName2}.sql";
string script1FullPath = Path.Combine(devScriptsBaseFolderPath, _relFolder_Incremental, scriptFilename);
return(script1FullPath);
}
private void JDockForm_Load(object sender, EventArgs e)
{
InitMenu();
if (this is IFile)
{
IFile file = this as IFile;
this.saveFileDialog1.Filter = Tools.GetFileDialogFilter(file.Extension);
}
if (this is IDB)
{
ConnectionInfo = new DBConnectionInfo();
}
}
