/// <summary>
/// Refresh the content
/// </summary>
public void RefreshContent()
{
if (chooseSource == null || chooseSource.DatabaseConnection == lastDbConn)
{
return;
}
lastDbConn = chooseSource.DatabaseConnection;
var options = new Dictionary <string, bool>();
if (lastDbConn.InputSource == InputSource.Database)
{
var df = new DataFactory(lastDbConn.Provider, lastDbConn.ConnectionString);
foreach (var item in df.Database.GetTables())
{
options.Add(item.TableName, false);
}
}
else
{
var opt = lastDbConn.Options; // + "; ImportMaxRows=1";
using (var ds = ImportManager.Import(lastDbConn.Filename, opt))
{
foreach (DataTable dt in ds.Tables)
{
options.Add(dt.TableName, false);
}
}
}
Options = options;
}
protected DatabaseFacade(DataConnectionInfo info)
{
ServerName = info.ServerName;
DatabaseName = info.DatabaseName;
Username = info.Username;
Password = info.Password;
}
public JsonNetResult CreateNewConnection(DataConnectionInfo connectionInfo)
{
Exception ex;
if (!validateConnection(connectionInfo, out ex))
{
// TODO: return errorResult
throw ex;
}
// Check connection
bool testResult = _dataSourceService.TestConnection(connectionInfo);
if (!testResult)
{
return(new JsonNetResult
{
Data = new ErrorResult("Unable to connect to the server. Please check the connection parameters and try again.")
});
}
var newConnectionResult = _dataSourceService.CreateConnection(connectionInfo);
return(new JsonNetResult
{
Data = newConnectionResult
});
}
public DataConnectionInfo CreateConnection(string serverName, string databaseName, string username, string password, DataConnectionType type)
{
try
{
var db = SqlDatabaseFactory.Create(Constants.ConnectionStrings.Core);
var command = db.GetStoredProcCommand("[dbo].[pr_CreateDataConnectionInfo]");
db.AddInParameter(command, "@server_name", SqlDbType.NVarChar, serverName);
db.AddInParameter(command, "@database_name", SqlDbType.NVarChar, databaseName);
db.AddInParameter(command, "@username", SqlDbType.NVarChar, username);
db.AddInParameter(command, "@password", SqlDbType.NVarChar, password);
db.AddInParameter(command, "@type", SqlDbType.SmallInt, type);
using (DataSet dataSet = db.ExecuteDataSet(command))
{
var connectionInfo = new DataConnectionInfo();
connectionInfo.DatabaseName = databaseName;
connectionInfo.ServerName = serverName;
connectionInfo.Username = username;
connectionInfo.Password = password;
connectionInfo.ConnectionType = type;
connectionInfo.DataConnectionInfoId = dataSet.Tables[0].Rows[0].Field <long>(0);
connectionInfo.ModifiedOn = DateTime.Now;
connectionInfo.CreatedOn = DateTime.Now;
return(connectionInfo);
}
}
catch (Exception ex)
{
throw new BasicDataException(string.Format("An unexpected error occurred while creating a connection. ERROR: {0}", ex.Message), ex);
}
}
/// <summary>
/// Constructor initializes the instance specific DataSyncManager and sets up all
/// objects needed to perform CompareForSync() and Sync() methods from the
/// source server and target connection. The source server may be a custom server
/// model pulled from a Json file or created on the fly and passed to this DataSyncManager object.
/// </summary>
/// <param name="sourceServer">The source Server object.</param>
/// <param name="targetDataConnectionInfo">target data connection info</param>
/// <param name="dataProperties">data properties</param>
protected DataSyncManager(Server sourceServer, DataConnectionInfo targetDataConnectionInfo, DataProperties dataProperties)
{
throw new NotImplementedException();
Exceptions = new List <Exception>();
DataTimer = new DataTimer();
DataSyncActionsCollection = new DataSyncActionsCollection();
DataProperties = dataProperties ?? new DataProperties();
TotalDataEventWaitTime = new TimeSpan(DateTime.Now.Ticks);
TotalDataEventWaitTime = TotalDataEventWaitTime.Subtract(TotalDataEventWaitTime);
SourceDataConnectionInfo = null;
SourceDataConnectionManager = null;
SourceServer = sourceServer; // Could be null...
TargetServer = null;
try
{
TargetDataConnectionInfo = targetDataConnectionInfo;
}
catch (Exception ex)
{
TargetDataConnectionInfo = null;
TargetDataConnectionManager = null;
Exceptions.Add(ex);
}
}
private void Form1_Load(object sender, EventArgs e)
{
var result = new DataConnectionInfo();
result.ConnectionString = "data source=(local); integrated security=true; initial catalog=ReAlignWorkDB";
result.Provider = DatabaseProvider.SqlClient;
OpenDatabase(result);
}
/// <summary>
/// Create a new connection info in our data.
/// </summary>
/// <param name="connectionInfo"></param>
/// <returns></returns>
public DataConnectionInfo CreateConnection(DataConnectionInfo connectionInfo)
{
return(_dataSourceRepository.CreateConnection(
connectionInfo.ServerName,
connectionInfo.DatabaseName,
connectionInfo.Username,
connectionInfo.Password,
connectionInfo.ConnectionType));
}
public static DatabaseFacade Create(DataConnectionInfo info)
{
switch (info.ConnectionType)
{
case DataConnectionType.MsSqlServer:
return(new SqlServerDatabaseFacade(info));
default:
throw new BasicException("Database type is not yet supported.", string.Format("InfoId: {0} Connection Type: {1}", info.DataConnectionInfoId, info.ConnectionType));
}
}
private DataConnectionInfo convertDataRowToDataConnectionInfo(DataRow row)
{
var connection = new DataConnectionInfo();
connection.DataConnectionInfoId = row.Field <int>("data_connection_info_id");
connection.ConnectionType = (DataConnectionType)row.Field <short>("data_connection_info_type_id");
connection.ServerName = row.Field <string>("server_name");
connection.DatabaseName = row.Field <string>("database_name");
connection.Username = row.Field <string>("user_name");
connection.Password = row.Field <string>("password");
return(connection);
}
private void button1_Click(object sender, EventArgs e)
{
try
{
DataConnectionInfo.Validate();
this.DialogResult = DialogResult.OK;
this.Close();
}
catch (Exception ex)
{
FormUtil.WinException(ex);
}
}
private void btnBuildConnectString_Click(object sender, EventArgs e)
{
try
{
FormUtil.Busy(this, true);
dci = ControlManager.ShowConnectionStringBuilder(ConnectionString, DatabaseProvider, AllowUserToChangeProvider);
ConnectionString = dci.ConnectionString;
DatabaseProvider = dci.Provider;
}
catch (Exception ex)
{
FormUtil.WinException(ex);
}
finally
{
FormUtil.Busy(this, false);
txtQuery.Focus();
}
}
private bool validateConnection(DataConnectionInfo connectionInfo, out Exception exception)
{
exception = null;
if (connectionInfo == null)
{
exception = new BasicException("Invalid request.", "viewModel is null.");
return(false);
}
if (string.IsNullOrWhiteSpace(connectionInfo.ServerName))
{
exception = new BasicException("The 'Server Name' field is required.", "Name field is empty in Data Source request.");
return(false);
}
if (string.IsNullOrWhiteSpace(connectionInfo.DatabaseName))
{
exception = new BasicException("The 'Database Name' field is required.", "Name field is empty in Data Source request.");
return(false);
}
if (string.IsNullOrWhiteSpace(connectionInfo.Username))
{
exception = new BasicException("The 'Username' field is required.", "Name field is empty in Data Source request.");
return(false);
}
if (string.IsNullOrWhiteSpace(connectionInfo.Password))
{
exception = new BasicException("The 'Password' field is required.", "Name field is empty in Data Source request.");
return(false);
}
return(true);
}
public MySqlSyncManager(DataConnectionInfo sourceDataConnectionInfo, DataConnectionInfo targetDataConnectionInfo, DataProperties dataProperties)
: base(sourceDataConnectionInfo, targetDataConnectionInfo, dataProperties)
{
}
public bool TestConnection(DataConnectionInfo info)
{
var databaseFacade = DatabaseFacadeFactory.Create(info);
return(databaseFacade.TestConnection());
}
public SqlServerDatabaseFacade(DataConnectionInfo info)
: base(info)
{
}
public SqlServerSyncManager(Server sourceServer, DataConnectionInfo targetDataConnectionInfo, DataProperties dataProperties)
: base(sourceServer, targetDataConnectionInfo, dataProperties)
{
}
/// <summary>
/// Export a DataSet to a file
/// </summary>
/// <param name="ds"></param>
/// <param name="connectionSpec"></param>
public static void Export(DataSet ds, DataConnectionInfo connectionSpec)
{
Export(ds, connectionSpec.Filename, connectionSpec.Options);
}
/// <summary>
/// Import the file and return a DataSet
/// </summary>
/// <param name="connectionSpec"></param>
/// <returns></returns>
public static DataSet Import(DataConnectionInfo connectionSpec)
{
return(Import(connectionSpec.Filename, connectionSpec.Options));
}
/// <summary>
/// Get tables from the actual data connection source
/// </summary>
/// <param name="info">The connection info to get the tables from.</param>
/// <returns></returns>
public List <TableInfo> GetTablesFromSource(DataConnectionInfo info)
{
var databaseFacade = DatabaseFacadeFactory.Create(info);
return(databaseFacade.GetTables());
}
private void OpenDatabase(DataConnectionInfo result)
{
dbo.ConnectionString = result.ConnectionString;
dbo.Provider = result.Provider;
dbo.RefreshTableList();
}
/// <summary>
/// Create a new instance with given attributes
/// </summary>
/// <param name="dbConnection"></param>
public DataFactory(DataConnectionInfo dbConnection)
: this(dbConnection.Provider, dbConnection.ConnectionString)
{
}
