public CSqlOptions CreateCsqlOptions()
{
DbConnectionParameter connectionParameter = new DbConnectionParameter();
connectionParameter.Provider = this.System;
connectionParameter.DatasourceAddress = this.Server;
connectionParameter.DatasourcePort = this.ServerPort;
connectionParameter.Catalog = this.Database;
connectionParameter.UserId = this.User;
connectionParameter.Password = this.Password;
connectionParameter.IntegratedSecurity = string.IsNullOrEmpty(this.User);
CSqlOptions csqlOptions = new CSqlOptions();
csqlOptions.ConnectionParameter = connectionParameter;
csqlOptions.ScriptFile = this.ScriptFile;
csqlOptions.TempFile = this.TempFile;
csqlOptions.DistributionFile = this.DistFile;
csqlOptions.UsePreprocessor = this.UsePreprocessor;
csqlOptions.BreakOnError = this.BreakOnError;
csqlOptions.NoLogo = this.NoLogo;
csqlOptions.Verbosity.Level = (TraceLevel)Verbose;
csqlOptions.PreprocessorOptions.AdvancedArguments = this.PreprocessorArgs;
csqlOptions.AddPreprocessorMacros();
return(csqlOptions);
}
private void DbConnectionParameter_PropertyChangedTimer_Tick(object sender, EventArgs e)
{
Timer timer = (Timer)sender;
string propertyName = (string)timer.Tag;
timer.Stop();
this.ignoreParameterPropertyChanges = true;
try {
DbConnectionParameter parameter = this.dbConnectionParameter;
switch (propertyName)
{
case "Provider":
SelectMruDatasource(parameter, mruConnections);
break;
case "DatasourceComment":
SelectMruDatasourceParameterByComment(parameter, mruConnections);
break;
case "DatasourceAddress":
SelectMruDatasourceParameterByAddress(parameter, mruConnections);
break;
case "DatasourcePort":
SelectMruDatasourceParameterByAddress(parameter, mruConnections);
break;
}
this.propertyGrid.Refresh();
}
finally {
this.ignoreParameterPropertyChanges = false;
}
}
public string GetConnectionString(DbConnectionParameter parameter)
{
SqlConnectionStringBuilder connectionStringBuilder = new SqlConnectionStringBuilder();
if (!String.IsNullOrEmpty(parameter.DatasourceAddress))
{
connectionStringBuilder.DataSource = parameter.DatasourceAddress;
}
if (!String.IsNullOrEmpty(parameter.Catalog))
{
connectionStringBuilder.InitialCatalog = parameter.Catalog;
}
connectionStringBuilder.IntegratedSecurity = parameter.IntegratedSecurity;
if (!String.IsNullOrEmpty(parameter.UserId))
{
connectionStringBuilder.UserID = parameter.UserId;
connectionStringBuilder.Password = parameter.Password ?? "";
}
if (parameter.Timeout > 0)
{
connectionStringBuilder.ConnectTimeout = parameter.Timeout;
}
return(connectionStringBuilder.ConnectionString);
}
/// <summary>
/// Defines the method to be called when the command is invoked.
/// </summary>
/// <param name="parameter">The connection parameter.</param>
public void Execute(object parameter)
{
DbConnectionParameter connectionParameter = (DbConnectionParameter)parameter;
IWrappedDbConnectionFactory connectionFactory = DbConnectionFactoryProvider.GetFactory(connectionParameter.Provider);
WrappedDbConnection dbConnection = null;
bool succeeded = false;
try {
dbConnection = connectionFactory.CreateConnection(connectionParameter);
succeeded = true;
}
catch (WrappedDbException) {
}
finally {
if (dbConnection != null)
{
dbConnection.Dispose();
}
}
if (succeeded)
{
MessageBox.Show("Connection succeeded", "Connection Test", MessageBoxButton.OK, MessageBoxImage.Information);
}
else
{
MessageBox.Show("Connection failed", "Connection Test", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
/// <summary>
/// Defines the method that determines whether the command can execute in its current state.
/// </summary>
/// <param name="parameter">The connection parameter.</param>
/// <returns>
/// true if this command can be executed; otherwise, false.
/// </returns>
public bool CanExecute(object parameter)
{
if (!(parameter is DbConnectionParameter))
{
return(false);
}
DbConnectionParameter connectionParameter = (DbConnectionParameter)parameter;
if (connectionParameter == null || connectionParameter.Provider == ProviderType.Undefined)
{
return(false);
}
if (!connectionParameter.IntegratedSecurity)
{
if (String.IsNullOrEmpty(connectionParameter.UserId))
{
return(false);
}
}
return(true);
}
public string GetConnectionString(DbConnectionParameter parameter)
{
StringBuilder sb = new StringBuilder();
if (!String.IsNullOrEmpty(parameter.DatasourceAddress))
{
sb.Append("DataSource=").Append(parameter.DatasourceAddress).Append(";");
}
if (!String.IsNullOrEmpty(parameter.Catalog))
{
sb.Append("Database=").Append(parameter.Catalog).Append(";");
}
if (!String.IsNullOrEmpty(parameter.UserId))
{
sb.Append("User ID=").Append(parameter.UserId).Append(";");
sb.Append("Password="******";");
}
else
{
sb.Append("Integrated Security=SSPI;");
}
if (!String.IsNullOrEmpty(parameter.ApplicationName))
{
sb.Append("Application Name=").Append(parameter.ApplicationName).Append(";");
}
// The following property is a work around for the
// error "30182 Invalid amount of parameters Optionen" sometime
// raised by the provider if it encounters variable names.
sb.Append("NamedParameters=false;");
string connectionString = sb.ToString();
return(connectionString);
}
/// <summary>
/// Initializes a new instance of the <see cref="ExecutionProcessor"/> class.
/// </summary>
/// <param name="cmdArgs">The CMD args.</param>
public ExecutionProcessor(CSqlOptions csqlOptions)
{
this.options = csqlOptions;
DbConnectionParameter connectionParameter = csqlOptions.ConnectionParameter;
this.connection = DbConnectionFactoryProvider.CreateConnection(connectionParameter);
this.connection.InfoMessage += new EventHandler <DbMessageEventArgs>(InfoMessageEventHandler);
}
protected override IDbConnection CreateAdoConnection(DbConnectionParameter parameter)
{
var adoConnection = connectionFactory.CreateAdoConnection(parameter);
adoConnection.InfoMessage += new SqlCeInfoMessageEventHandler(InfoMessageHandler);
adoConnection.Open();
return(adoConnection);
}
/// <summary>
/// Creates the ADO.NET connection.
/// </summary>
/// <param name="parameter">The connection parameter.</param>
/// <returns>An open ADO connection.</returns>
internal System.Data.SqlServerCe.SqlCeConnection CreateAdoConnection(DbConnectionParameter parameter)
{
string connectionString = GetConnectionString(parameter);
Trace.WriteLineIf(parameter.VerbositySwitch.TraceVerbose, "Connecting to SQL CE database using following connection string:\r\n" + connectionString);
System.Data.SqlServerCe.SqlCeConnection connection = new System.Data.SqlServerCe.SqlCeConnection(connectionString);
return(connection);
}
/// <summary>
/// Creates the ADO.NET connection.
/// </summary>
/// <param name="parameter">The connection parameter.</param>
/// <returns>An open ADO connection.</returns>
internal SqlConnection CreateAdoConnection(DbConnectionParameter parameter)
{
string connectionString = GetConnectionString(parameter);
Trace.WriteLineIf(parameter.VerbositySwitch.TraceVerbose, "Connecting to MS SQL Server using following connection string:\r\n" + connectionString);
SqlConnection connection = new SqlConnection(connectionString);
return(connection);
}
private static DbConnectionParameter CreateDbConnectionParameter(DbConnectionParameter dbConnectionParameter, Document activeDocument)
{
DocumentEnvironment environment = new DocumentEnvironment(activeDocument);
VariableSubstitutor substitutor = new VariableSubstitutor(environment);
DbConnectionParameter dbConnectionParameterCopy = new DbConnectionParameter(dbConnectionParameter);
dbConnectionParameterCopy.DatasourceAddress = substitutor.Substitute(dbConnectionParameter.DatasourceAddress);
dbConnectionParameterCopy.Catalog = substitutor.Substitute(dbConnectionParameter.Catalog);
return(dbConnectionParameterCopy);
}
public UnitOfWork(DbConnectionParameter dbConnectionParameter)
{
if (dbConnectionParameter == DbConnectionParameter.eCollabro)
{
_context = new eCollabroDbModel();
}
//else if (dbConnectionParameter == DbConnectionParameter.ADP)
// _context = new ADPModel();
_context.Configuration.LazyLoadingEnabled = false;
_instanceId = Guid.NewGuid();
}
protected override IDbConnection CreateAdoConnection(DbConnectionParameter parameter)
{
string connectionString = connectionFactory.GetConnectionString(parameter);
Trace.WriteLineIf(parameter.VerbositySwitch.TraceVerbose, "Connecting to Sybase ASE Server using following connection string:\r\n" + connectionString);
IDbConnection adoConnection = CreateAseConnection();
adoConnection.ConnectionString = connectionString;
adoConnection.Open();
return(adoConnection);
}
public CSqlOptions()
{
this.connectionParameter = new DbConnectionParameter();
this.preprocessorOptions = new SqtppOptions();
this.verbosity = new VerbositySwitch();
DistributionFile = String.Empty;
TempFile = String.Empty;
ScriptFile = String.Empty;
BreakOnError = true;
UsePreprocessor = true;
MaxResultColumnWidth = 40;
}
private static void SelectMruDatasourceParameter( DbConnectionParameter parameter, Datasource datasource )
{
if ( datasource.Catalogs != null && datasource.Catalogs.Count > 0 ) {
string catalog = datasource.Catalogs[0];
parameter.Catalog = catalog;
}
if ( datasource.Authentications != null && datasource.Authentications.Count > 0 ) {
Authentication authentication = datasource.Authentications[0];
parameter.IntegratedSecurity = authentication.Integrated;
parameter.UserId = authentication.UserId;
parameter.Password = authentication.Password;
}
}
private static void SelectMruDatasource( DbConnectionParameter parameter, MruConnections mruConnection )
{
if ( mruConnection == null )
return;
var datasources = mruConnection.FindDatasources( parameter.Provider );
if ( datasources == null || datasources.Datasource == null || datasources.Datasource.Count == 0 )
return;
var datasource = datasources.Datasource[0];
parameter.DatasourceComment = datasource.Comment;
parameter.DatasourceAddress = datasource.Address;
SelectMruDatasourceParameter( parameter, datasource );
}
private static void SelectMruDatasourceParameterByComment( DbConnectionParameter parameter, MruConnections mruConnection )
{
if ( mruConnection == null )
return;
var provider = parameter.Provider;
var datasource = mruConnection.FindDatasourceByComment( ref provider, parameter.DatasourceComment );
if ( datasource == null )
return;
parameter.Provider = provider;
parameter.DatasourceComment = datasource.Comment;
parameter.DatasourceAddress = datasource.Address;
SelectMruDatasourceParameter( parameter, datasource );
}
/// <summary>
/// Stores the current database connection parameter in the global variables
/// of the visual studio environment.
/// </summary>
/// <param name="dbConnectionParameter">The database connection parameter.</param>
internal void SaveDbConnectionParameterInGlobals(DbConnectionParameter dbConnectionParameter)
{
IWrappedDbConnectionFactory factory = DbConnectionFactoryProvider.GetFactory(dbConnectionParameter.Provider);
string providerName = factory.ProviderName;
string connectionString = factory.GetConnectionString(dbConnectionParameter);
Globals globals = application.Globals;
string variableName = CSqlConnectionFactory.CSqlConnectionProviderVariableName;
globals[variableName] = providerName;
globals.set_VariablePersists(variableName, true);
variableName = CSqlConnectionFactory.CSqlConnectionStringVariableName;
globals[variableName] = connectionString;
globals.set_VariablePersists(variableName, true);
}
private void ReloadSettings()
{
SettingsManager settingsManager = SettingsManager.GetInstance( application );
this.mruConnections = settingsManager.MruDbConnectionParameters;
this.dbConnectionParameter = settingsManager.CurrentDbConnectionParameter;
this.scriptParameters = settingsManager.ScriptParameters;
InitObjectSelectionComboBox();
this.reloadSettings = false;
if ( dbConnectionParameter != null ) {
dbConnectionParameter.GetDatasourceNameValues += new EventHandler<StringLookupGetValuesEventArgs>( DbConnectionParameter_GetDatasourceNameValues );
dbConnectionParameter.GetDatasourceAddressValues += new EventHandler<StringLookupGetValuesEventArgs>( DbConnectionParameter_GetDatasourceAddressValues );
dbConnectionParameter.GetCatalogValues += new EventHandler<StringLookupGetValuesEventArgs>( DbConnectionParameter_GetCatalogValues );
dbConnectionParameter.GetUserIdValues += new EventHandler<StringLookupGetValuesEventArgs>( DbConnectionParameter_GetUserIdValues );
dbConnectionParameter.PropertyChanged += new PropertyChangedEventHandler( DbConnectionParameter_PropertyChanged );
}
}
private static BindingList<SelectedObjectComboBoxItem> CreateComboItems( DbConnectionParameter dbConnectionParameter, ScriptParameterCollection scriptParameters )
{
var result = new BindingList<SelectedObjectComboBoxItem>();
if ( dbConnectionParameter != null ) {
var connectionItem = new DbConnectionComboBoxItem( dbConnectionParameter );
result.Add( connectionItem );
}
if ( scriptParameters != null ) {
foreach ( var scriptParameter in scriptParameters ) {
var parameterItem = new SelectedScriptParameterComboBoxItem( scriptParameter );
parameterItem.IsCurrent = scriptParameter.Equals( scriptParameters.Current );
result.Add( parameterItem );
}
}
return result;
}
/// <summary>
/// Update the most recently used db connection parameter in the application data folder.
/// </summary>
/// <param name="dbConnectionParameter">The db connection parameter.</param>
internal void SaveDbConnectionParameterInMruHistory(DbConnectionParameter dbConnectionParameter)
{
MruConnections mruConnections = MruDbConnectionParameters;
if (mruConnections == null)
{
return;
}
bool parameterChanged = MruDbConnectionParameterAdapter.SetMruDbConnectionParameter(mruConnections, dbConnectionParameter);
if (!parameterChanged)
{
return;
}
string mruConnectionsPath = GetGlobalFilePath(MruConnectionFileName);
if (String.IsNullOrEmpty(mruConnectionsPath))
{
return;
}
try {
string directory = Path.GetDirectoryName(mruConnectionsPath);
Directory.CreateDirectory(directory);
using (Stream stream = new FileStream(mruConnectionsPath, FileMode.Create, FileAccess.Write, FileShare.None, 4096, FileOptions.SequentialScan)) {
XmlSchema xmlSchema = MruConnections.Schema;
XmlSerializer serializer = new XmlSerializer(typeof(MruConnections), xmlSchema.TargetNamespace);
serializer.Serialize(stream, mruConnections);
stream.Close();
}
}
catch (Exception ex) {
string context = MethodInfo.GetCurrentMethod().Name;
string message = String.Format("{0}: Failed to save connection settings because [{1}].", context, ex.Message);
Debug.WriteLine(message);
var outputPane = Output.GetAndActivateOutputPane((EnvDTE80.DTE2)application);
outputPane.OutputString(message);
}
}
private static CSqlOptions CreateCSqlOptions(DbConnectionParameter dbConnectionParameter, ScriptParameter csqlParameter, Document activeDocument)
{
CSqlOptions csqlOptions = new CSqlOptions();
DocumentEnvironment environment = new DocumentEnvironment(activeDocument);
VariableSubstitutor substitutor = new VariableSubstitutor(environment);
csqlOptions.ScriptFile = activeDocument.FullName;
if (csqlParameter.IsOutputFileEnabled)
{
string file = substitutor.Substitute(csqlParameter.OutputFile);
csqlOptions.DistributionFile = file;
}
else
{
csqlOptions.DistributionFile = null;
}
if (csqlParameter.IsTemporaryFileEnabled)
{
string file = substitutor.Substitute(csqlParameter.TemporaryFile);
csqlOptions.TempFile = file;
}
else
{
csqlOptions.TempFile = null;
}
csqlOptions.BreakOnError = csqlParameter.IsBreakOnErrorEnabled;
csqlOptions.UsePreprocessor = csqlParameter.IsPreprocessorEnabled;
csqlOptions.ConnectionParameter = dbConnectionParameter;
csqlOptions.PreprocessorOptions = CreatePreprocessorArguments(substitutor, csqlParameter);
csqlOptions.AddPreprocessorMacros();
csqlOptions.Verbosity.Level = csqlParameter.Verbosity;
csqlOptions.NoLogo = false;
csqlOptions.MaxResultColumnWidth = csqlParameter.MaxResultColumnWidth;
return(csqlOptions);
}
/// <inheritdoc/>
public string GetConnectionString(DbConnectionParameter parameter)
{
DbConnectionStringBuilder connectionStringBuilder = new DbConnectionStringBuilder();
string dataSource = string.Empty;
if (!string.IsNullOrEmpty(parameter.DatasourceAddress))
{
dataSource = parameter.DatasourceAddress;
}
if (!string.IsNullOrEmpty(parameter.Catalog))
{
dataSource = Path.Combine(dataSource, parameter.Catalog);
}
if (!string.IsNullOrEmpty(dataSource))
{
connectionStringBuilder.Add("Data Source", dataSource);
}
return(connectionStringBuilder.ConnectionString);
}
/// <inheritdoc/>
public WrappedDbConnection CreateConnection(DbConnectionParameter parameter)
{
var connection = new MsSqlWrappedConnection(this, parameter);
return(connection);
}
internal SqlCeWrappedConnection(SqlCeConnectionFactory connectionFactory, DbConnectionParameter parameter)
: base(parameter)
{
this.connectionFactory = connectionFactory;
}
internal DbConnectionComboBoxItem(DbConnectionParameter connectionParameter)
: base(connectionParameter)
{
}
public WrappedDbConnection CreateConnection(DbConnectionParameter parameter)
{
WrappedDbConnection connection = new SybaseConnection(this, parameter);
return(connection);
}
public SybaseConnection(SybaseConnectionFactory connectionFactory, DbConnectionParameter parameter)
: base(parameter)
{
this.connectionFactory = connectionFactory;
}
public WrappedDbConnection CreateConnection(DbConnectionParameter parameter)
{
throw new NotImplementedException();
}
public string GetConnectionString(DbConnectionParameter parameter)
{
throw new NotImplementedException();
}
