public void AddCe35Database(object sender, ExecutedRoutedEventArgs e)
{
// http://www.mztools.com/articles/2007/MZ2007011.aspx
if (!Helpers.DataConnectionHelper.DDEXProviderIsInstalled(new Guid(Resources.SqlCompact35Provider)))
{
EnvDTEHelper.ShowError("The version 3.5 Visual Studio DDEX provider is not installed, cannot add connection");
return;
}
try
{
var objIVsDataConnectionDialogFactory = package.GetServiceHelper(typeof(IVsDataConnectionDialogFactory)) as IVsDataConnectionDialogFactory;
var objIVsDataConnectionDialog = objIVsDataConnectionDialogFactory.CreateConnectionDialog();
objIVsDataConnectionDialog.AddAllSources();
objIVsDataConnectionDialog.SelectedSource = new Guid("130BADA6-E128-423c-9D07-02E4734D45D4");
objIVsDataConnectionDialog.SelectedProvider = new Guid(Resources.SqlCompact35Provider);
if (objIVsDataConnectionDialog.ShowDialog() && objIVsDataConnectionDialog.SelectedProvider == new Guid(Resources.SqlCompact35Provider))
{
Helpers.DataConnectionHelper.SaveDataConnection(package, objIVsDataConnectionDialog.EncryptedConnectionString, objIVsDataConnectionDialog.DisplayConnectionString, DatabaseType.SQLCE35, new Guid(Resources.SqlCompact35Provider));
ExplorerControl control = _parentWindow.Content as ExplorerControl;
control.BuildDatabaseTree();
Helpers.DataConnectionHelper.LogUsage("DatabasesAddCe35Database");
}
objIVsDataConnectionDialog.Dispose();
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, DatabaseType.SQLCE35);
}
}
public void DropSubscription(object sender, ExecutedRoutedEventArgs e)
{
if (EnvDTEHelper.ShowMessageBox("Do you really want to remove replication metadata from the SQL Server Compact database?", Microsoft.VisualStudio.Shell.Interop.OLEMSGBUTTON.OLEMSGBUTTON_YESNO, Microsoft.VisualStudio.Shell.Interop.OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_SECOND, Microsoft.VisualStudio.Shell.Interop.OLEMSGICON.OLEMSGICON_WARNING) == System.Windows.Forms.DialogResult.No)
{
return;
}
var menuItem = sender as MenuItem;
if (menuItem == null)
{
return;
}
var menuInfo = menuItem.CommandParameter as MenuCommandParameters;
if (menuInfo == null)
{
return;
}
try
{
SqlCeReplicationHelper.DropPublication(menuInfo.DatabaseInfo.ConnectionString, menuInfo.Name);
if (_parentWindow != null && _parentWindow.Content != null)
{
ExplorerControl control = _parentWindow.Content as ExplorerControl;
control.BuildDatabaseTree();
}
Helpers.DataConnectionHelper.LogUsage("SubscriptionDrop");
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, menuInfo.DatabaseInfo.DatabaseType, false);
}
}
public void DropScope(object sender, ExecutedRoutedEventArgs e)
{
if (EnvDTEHelper.ShowMessageBox("Do you really want to deprovision this scope?", Microsoft.VisualStudio.Shell.Interop.OLEMSGBUTTON.OLEMSGBUTTON_YESNO, Microsoft.VisualStudio.Shell.Interop.OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_SECOND, Microsoft.VisualStudio.Shell.Interop.OLEMSGICON.OLEMSGICON_WARNING) == System.Windows.Forms.DialogResult.No)
{
return;
}
var menuItem = sender as MenuItem;
if (menuItem == null)
{
return;
}
var menuInfo = menuItem.CommandParameter as MenuCommandParameters;
if (menuInfo == null)
{
return;
}
try
{
SyncFxHelper.DeprovisionSqlCeScope(menuInfo.DatabaseInfo.ConnectionString, menuInfo.Name);
EnvDTEHelper.ShowMessage("Scope deprovisioned");
if (_parentWindow != null && _parentWindow.Content != null)
{
ExplorerControl control = _parentWindow.Content as ExplorerControl;
control.BuildDatabaseTree();
}
Helpers.DataConnectionHelper.LogUsage("SyncScopeDrop");
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, menuInfo.DatabaseInfo.DatabaseType);
}
}
public int OnClose(ref uint pgrfSaveOptions)
{
if (!Properties.Settings.Default.PromptToSaveChangedScript)
{
return(Microsoft.VisualStudio.VSConstants.S_OK);
}
// Check if your content is dirty here, then
var window = this.control as SqlEditorControl;
if (window != null && window.IsDirty && !mustClose)
{
// Prompt a dialog
DialogResult res = EnvDTEHelper.ShowMessageBox("This script has been modified. Do you want to save the changes ?", OLEMSGBUTTON.OLEMSGBUTTON_YESNOCANCEL, OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST, OLEMSGICON.OLEMSGICON_QUERY);
// If the users wants to save
if (res == DialogResult.Yes)
{
window.SaveScript(true);
}
if (res == DialogResult.Cancel)
{
// If "cancel" is clicked, abort the close
return(Microsoft.VisualStudio.VSConstants.E_ABORT);
}
if (res == DialogResult.No)
{
mustClose = true;
}
}
return(Microsoft.VisualStudio.VSConstants.S_OK);
}
private void ShowPlanButton_Click(object sender, RoutedEventArgs e)
{
if (string.IsNullOrWhiteSpace(SqlText))
{
return;
}
Helpers.DataConnectionHelper.LogUsage("EditorShowPlan");
try
{
using (var repository = Helpers.DataConnectionHelper.CreateRepository(DatabaseInfo))
{
var textBox = new TextBox();
textBox.FontFamily = fontFamiliy;
textBox.FontSize = fontSize;
string sql = GetSqlFromSqlEditorTextBox();
string showPlan = repository.ParseSql(sql);
try
{
TryLaunchSqlplan(showPlan);
}
catch (System.ComponentModel.Win32Exception)
{
EnvDTEHelper.ShowError("This feature requires Visual Studio 2010 Premium / SQL Server Management Studio to be installed");
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, DatabaseType.SQLCE35);
}
}
}
catch (Exception sqlException)
{
ParseSqlErrorToResultsBox(Helpers.DataConnectionHelper.CreateEngineHelper(DatabaseInfo.DatabaseType).FormatError(sqlException));
}
}
private void RuntimeMissing_Click(object sender, RoutedEventArgs e)
{
if (!DataConnectionHelper.IsV35Installed() && !DataConnectionHelper.IsV40Installed())
{
EnvDTEHelper.ShowMessage("The SQL Server Compact 3.5 SP2 and 4.0 runtimes are not properly installed,\r\nso many features are not available,\r\ninstall or repair SQL Server Compact 3.5 SP2 or 4.0 Desktop to remedy");
}
}
private bool SaveSettings()
{
try
{
TableName = this.txtTableDesc.Text;
if (string.IsNullOrEmpty(TableName))
{
EnvDTEHelper.ShowError("Table name is required");
return(false);
}
var validation = TableColumn.ValidateColumns(columns.ToList());
if (!string.IsNullOrEmpty(validation))
{
EnvDTEHelper.ShowError(validation);
return(false);
}
TableColumns = TableColumn.BuildColumns(columns.ToList(), TableName);
PkScript = TableColumn.BuildPkScript(columns.ToList(), TableName);
if (_dbType == DatabaseType.SQLite)
{
PkScript = BuildSQLitePkScript(columns.ToList(), TableName);
}
else
{
PkScript = TableColumn.BuildPkScript(columns.ToList(), TableName);
}
return(true);
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, DatabaseType.SQLServer);
}
return(false);
}
private void projectItemGenerator_ProjectItemDeleted(object sender, ProjectItemDeletedEventArgs e)
{
try
{
var project = EnvDTEHelper.Instance.GetProject(e.ProjectName);
var parent = EnvDTEHelper.Instance.GetProjectItem(e.ProjectName, e.ParentItemName, e.ParentItemType);
var fileStateInfo = new FileStateInfo();
if (e.ParentItemName != string.Empty)
{
EnvDTEHelper.Instance.DeleteProjectItem(parent, e.ProjectItemName, out fileStateInfo);
}
else
{
EnvDTEHelper.DeleteProjectItem(project, e.ProjectItemName, out fileStateInfo);
}
Application.DoEvents();
//Write Log
nHydrateLog.LogInfo("Project Item Deleted: {0}", e.ProjectItemName);
e.FileState = fileStateInfo.FileState;
e.FullName = fileStateInfo.FileName;
//this.OnProjectItemGenerated(sender, e);
}
catch (Exception ex)
{
//this.OnProjectItemGeneratedError(this, e);
nHydrateLog.LogWarning(ex);
}
}
private void ResultsetGrid_Load(object sender, EventArgs e)
{
this.tableName = TableName;
try
{
this.dataGridView1.AutoGenerateColumns = true;
this.dataGridView1.DataError += new DataGridViewDataErrorEventHandler(dataGridView1_DataError);
imageContext.Items.Add("Import Image", null, new EventHandler(ImportImage));
imageContext.Items.Add("Export Image", null, new EventHandler(ExportImage));
imageContext.Items.Add("Delete Image", null, new EventHandler(DeleteImage));
LoadData(SqlText);
this.dataGridView1.ReadOnly = ReadOnly;
if (this.ReadOnlyColumns != null)
{
foreach (int x in ReadOnlyColumns)
{
this.dataGridView1.Columns[x].ReadOnly = true;
this.dataGridView1.Columns[x].DefaultCellStyle.ForeColor = SystemColors.GrayText;
}
}
if (Properties.Settings.Default.MultiLineTextEntry)
{
foreach (DataGridViewColumn col in dataGridView1.Columns)
{
if (col is DataGridViewTextBoxColumn)
{
col.DefaultCellStyle.WrapMode = DataGridViewTriState.True;
}
}
this.dataGridView1.AutoSizeRowsMode = DataGridViewAutoSizeRowsMode.AllCells;
}
this.bindingNavigatorAddNewItem.Enabled = !ReadOnly;
this.bindingNavigatorDeleteItem.Enabled = !ReadOnly;
this.toolStripButton1.Enabled = !ReadOnly;
this.dataGridView1.ClipboardCopyMode = DataGridViewClipboardCopyMode.EnableAlwaysIncludeHeaderText;
this.dataGridView1.AllowUserToOrderColumns = true;
this.dataGridView1.MultiSelect = false;
//if (Properties.Settings.Default.ShowNullValuesAsNULL)
//{
// this.dataGridView1.DefaultCellStyle.NullValue = "NULL";
//}
this.dataGridView1.KeyDown += new KeyEventHandler(dataGridView1_KeyDown);
//this.dataGridView1.CellContentClick += new DataGridViewCellEventHandler(dataGridView1_CellContentClick);
dgs = new DataGridViewSearch(this.dataGridView1);
if (ReadOnly)
{
this.dataGridView1.DefaultCellStyle.ForeColor = SystemColors.GrayText;
EnvDTEHelper.ShowError("No primary keys on table, data is read-only");
}
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, DatabaseInfo.DatabaseType, false);
}
}
public void ImportData(object sender, ExecutedRoutedEventArgs e)
{
var menuInfo = ValidateMenuInfo(sender);
if (menuInfo == null)
{
return;
}
try
{
using (var repository = DataConnectionHelper.CreateRepository(menuInfo.DatabaseInfo))
{
var generator = DataConnectionHelper.CreateGenerator(repository, menuInfo.DatabaseInfo.DatabaseType);
var imo = new ImportDialog
{
SampleHeader = generator.GenerateTableColumns(menuInfo.Name),
Separator =
System.Globalization.CultureInfo.CurrentCulture.TextInfo.ListSeparator.ToCharArray()[0]
};
if (imo.ShowModal() != true)
{
return;
}
if (string.IsNullOrWhiteSpace(imo.File) || !System.IO.File.Exists(imo.File))
{
return;
}
using (var reader = new CsvReader(imo.File, Encoding.UTF8))
{
reader.ValueSeparator = imo.Separator;
var hr = reader.ReadHeaderRecord();
if (generator.ValidColumns(menuInfo.Name, hr.Values))
{
var i = 1;
foreach (var record in reader.DataRecords)
{
generator.GenerateTableInsert(menuInfo.Name, hr.Values, record.Values, i);
i++;
}
}
}
OpenSqlEditorToolWindow(menuInfo, generator.GeneratedScript);
DataConnectionHelper.LogUsage("TableImport");
}
}
catch (System.IO.IOException iox)
{
EnvDTEHelper.ShowError(iox.Message);
}
catch (Exception ex)
{
DataConnectionHelper.SendError(ex, menuInfo.DatabaseInfo.DatabaseType, false);
}
}
public void ReportTableData(object sender, ExecutedRoutedEventArgs e)
{
string sqlText = null;
var menuItem = sender as MenuItem;
var ds = new DataSet();
if (menuItem == null)
{
return;
}
var menuInfo = menuItem.CommandParameter as MenuCommandParameters;
if (menuInfo == null)
{
return;
}
try
{
using (IRepository repository = Helpers.DataConnectionHelper.CreateRepository(menuInfo.DatabaseInfo))
{
sqlText = string.Format(Environment.NewLine + "SELECT * FROM [{0}]", menuInfo.Name)
+ Environment.NewLine + "GO";
ds = repository.ExecuteSql(sqlText);
}
var pkg = ParentWindow.Package as SqlCeToolboxPackage;
Debug.Assert(pkg != null, "Package property of the Explorere Tool Window should never be null, have you tried to create it manually and not through FindToolWindow()?");
string dbName = System.IO.Path.GetFileNameWithoutExtension(menuInfo.DatabaseInfo.Caption);
var window = pkg.CreateWindow <ReportWindow>(Math.Abs(menuInfo.Name.GetHashCode() - dbName.GetHashCode()));
window.Caption = menuInfo.Name + " (" + dbName + ")";
pkg.ShowWindow(window);
var control = window.Content as ReportControl;
control.DatabaseInfo = menuInfo.DatabaseInfo;
control.TableName = menuInfo.Name;
control.DataSet = ds;
control.ShowReport();
DataConnectionHelper.LogUsage("ViewReport");
}
catch (System.IO.FileNotFoundException)
{
EnvDTEHelper.ShowError("Microsoft Report Viewer 2010 not installed, please download and install to use this feature http://www.microsoft.com/en-us/download/details.aspx?id=6442");
return;
}
catch (Exception ex)
{
DataConnectionHelper.SendError(ex, menuInfo.DatabaseInfo.DatabaseType, false);
}
ds.Dispose();
}
private bool TryGetInitialPath(SqlCeToolboxPackage package, out string path)
{
var dte = package.GetServiceHelper(typeof(EnvDTE.DTE)) as EnvDTE.DTE;
EnvDTEHelper dteHelper = new EnvDTEHelper();
try
{
path = dteHelper.GetInitialFolder(dte);
return(true);
}
catch
{
path = null;
return(false);
}
}
private void TryLaunchSqlplan(string showPlan)
{
if (!string.IsNullOrWhiteSpace(showPlan))
{
if (DatabaseInfo.DatabaseType == DatabaseType.SQLite)
{
var textBox = new TextBox();
textBox.FontFamily = fontFamiliy;
textBox.FontSize = fontSize;
textBox.Text = showPlan;
ClearResults();
this.Resultspanel.Children.Add(textBox);
this.tab1.Visibility = System.Windows.Visibility.Collapsed;
resultsTabControl.SelectedIndex = 1;
}
else
{
var fileName = System.IO.Path.GetTempFileName();
fileName = fileName + ".sqlplan";
System.IO.File.WriteAllText(fileName, showPlan);
// If Data Dude is available
var pkg = _parentWindow.Package as SqlCeToolboxPackage;
if (pkg.VSSupportsSqlPlan())
{
dte.ItemOperations.OpenFile(fileName);
dte.ActiveDocument.Activate();
}
else
{
// Just try to start SSMS
using (RegistryKey rkRoot = Registry.ClassesRoot)
{
RegistryKey rkFileType = rkRoot.OpenSubKey(".sqlplan");
if (rkFileType != null)
{
System.Diagnostics.Process.Start(fileName);
}
else
{
EnvDTEHelper.ShowError("No application that can open .sqlplan files is installed, you could install SSMS 2012 SP1 Express");
}
}
}
}
}
}
public void CheckCeVersion(object sender, ExecutedRoutedEventArgs e)
{
var helper = Helpers.DataConnectionHelper.CreateEngineHelper(DatabaseType.SQLCE40);
OpenFileDialog ofd = new OpenFileDialog();
ofd.Filter = DataConnectionHelper.GetSqlCeFileFilter();
ofd.CheckFileExists = true;
ofd.Multiselect = false;
ofd.ValidateNames = true;
if (ofd.ShowDialog() == true)
{
try
{
var sdfVersion = helper.DetermineVersion(ofd.FileName);
string found = "Unknown";
switch (sdfVersion)
{
case SQLCEVersion.SQLCE20:
found = "2.0";
break;
case SQLCEVersion.SQLCE30:
found = "3.0/3.1";
break;
case SQLCEVersion.SQLCE35:
found = "3.5";
break;
case SQLCEVersion.SQLCE40:
found = "4.0";
break;
default:
break;
}
EnvDTEHelper.ShowMessage(string.Format("{0} is SQL Server Compact version {1}", Path.GetFileName(ofd.FileName), found));
Helpers.DataConnectionHelper.LogUsage("DatabaseVersionDetect");
}
catch (Exception ex)
{
EnvDTEHelper.ShowError(ex.Message);
}
}
}
public void ModifyColumn(object sender, ExecutedRoutedEventArgs e)
{
var menuItem = sender as MenuItem;
if (menuItem == null)
{
return;
}
var menuInfo = menuItem.CommandParameter as MenuCommandParameters;
if (menuInfo == null)
{
return;
}
try
{
using (IRepository repository = Helpers.DataConnectionHelper.CreateRepository(menuInfo.DatabaseInfo))
{
var generator = Helpers.DataConnectionHelper.CreateGenerator(repository, menuInfo.DatabaseInfo.DatabaseType);
List <Column> columns = repository.GetAllColumns();
var col = columns.SingleOrDefault(c => c.TableName == menuInfo.Description && c.ColumnName == menuInfo.Name);
if (col == null)
{
EnvDTEHelper.ShowError("Could not find the column in the table, has it been dropped?");
return;
}
TableBuilderDialog tbd = new TableBuilderDialog(menuInfo.Description, menuInfo.DatabaseInfo.DatabaseType);
tbd.TableColumns = new List <Column> {
col
};
tbd.Mode = 2;
if (tbd.ShowModal() == true && tbd.TableColumns.Count == 1)
{
generator.GenerateColumnAlterScript(tbd.TableColumns[0]);
var script = generator.GeneratedScript.ToString();
OpenSqlEditorToolWindow(menuInfo, script);
Helpers.DataConnectionHelper.LogUsage("TableBuildColumnEdit");
}
}
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, menuInfo.DatabaseInfo.DatabaseType);
}
}
public sealed override void RunStarted(object automationObject, Dictionary <string, string> replacementsDictionary, WizardRunKind runKind, object[] customParams)
{
_dte = (DTE2)automationObject;
_currentProject = EnvDTEHelper.GetCurrentProject();
_project = EnvDTEProject.From(_currentProject);
_referenceService = new ProjectSystemReferenceService();
_packageService = new ProjectSystemPackageService();
RootNamespace = replacementsDictionary["$rootnamespace$"];
RootName = replacementsDictionary["$rootname$"];
if (RootName.Contains("."))
{
RootName = Path.GetFileNameWithoutExtension(RootName);
}
RunStartedCore(replacementsDictionary);
}
private void SaveButton_Click(object sender, RoutedEventArgs e)
{
if (cmbColumns.SelectedIndex == -1)
{
EnvDTEHelper.ShowError("Please select a column");
return;
}
if (string.IsNullOrEmpty(dataSourceTextBox.Text))
{
EnvDTEHelper.ShowError("Please enter an index name");
return;
}
newIndex.IndexName = dataSourceTextBox.Text;
newIndex.ColumnName = cmbColumns.SelectedItem.ToString();
newIndex.TableName = _tableName;
newIndex.Unique = chkUnique.IsChecked.Value;
this.DialogResult = true;
Close();
}
public void ScriptAsCreate(object sender, ExecutedRoutedEventArgs e)
{
var menuItem = sender as MenuItem;
if (menuItem == null)
{
return;
}
var menuInfo = menuItem.CommandParameter as MenuCommandParameters;
if (menuInfo == null)
{
return;
}
try
{
using (IRepository repository = Helpers.DataConnectionHelper.CreateRepository(menuInfo.DatabaseInfo))
{
var generator = Helpers.DataConnectionHelper.CreateGenerator(repository, menuInfo.DatabaseInfo.DatabaseType);
List <Column> columns = repository.GetAllColumns();
var col = columns.SingleOrDefault(c => c.TableName == menuInfo.Description && c.ColumnName == menuInfo.Name);
if (col == null)
{
EnvDTEHelper.ShowError("Could not find the column in the table, has it been dropped?");
return;
}
else
{
generator.GenerateColumnAddScript(col);
}
OpenSqlEditorToolWindow(menuInfo, generator.GeneratedScript);
Helpers.DataConnectionHelper.LogUsage("ColumnScriptAsCreate");
}
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, menuInfo.DatabaseInfo.DatabaseType, false);
}
}
protected override void GenerateProject(IGenerator generator, Type projectGeneratorType)
{
try
{
var projectGenerator = GetProjectGenerator(projectGeneratorType);
projectGenerator.Initialize(generator.Model);
if (!EnvDTEHelper.ProjectExists(projectGenerator.ProjectName))
{
CreateProject(generator, projectGeneratorType, string.Empty);
}
else if (!EnvDTEHelper.ProjectLoaded(projectGenerator.ProjectName))
{
//LoadProject(generator, projectGeneratorType);
_errorList.Add($"The project '{projectGenerator.ProjectName}' is unloaded and cannot be generated.");
return;
}
GenerateProjectItems(projectGenerator);
}
catch (Exception ex)
{
throw;
}
}
private void SaveButton_Click(object sender, RoutedEventArgs e)
{
if (string.IsNullOrEmpty(dataSourceTextBox.Text))
{
EnvDTEHelper.ShowError("Please enter a foreign key name");
return;
}
if (cmbFkColumn.SelectedIndex == -1)
{
EnvDTEHelper.ShowError("Please select a foreign key column");
return;
}
if (cmbPrimaryKeyTableAndColumn.SelectedIndex == -1)
{
EnvDTEHelper.ShowError("Please select a primary key");
return;
}
newKey.ColumnName = cmbFkColumn.SelectedItem.ToString();
newKey.Columns = new ColumnList {
cmbFkColumn.SelectedItem.ToString()
};
newKey.ConstraintName = dataSourceTextBox.Text;
newKey.ConstraintTableName = _tableName;
newKey.DeleteRule = cmbDeleteAction.SelectedItem.ToString();
newKey.UpdateRule = cmbUpdateAction.SelectedItem.ToString();
PrimaryKey pk = (PrimaryKey)cmbPrimaryKeyTableAndColumn.SelectedValue;
newKey.UniqueColumns = new ColumnList {
pk.ColumnName
};
newKey.UniqueConstraintTableName = pk.TableName;
this.DialogResult = true;
Close();
}
private void GenerateProject(IGenerator generator, Type projectGeneratorType)
{
try
{
var projectGenerator = GetProjectGenerator(projectGeneratorType);
projectGenerator.Initialize(generator.Model);
if (!EnvDTEHelper.ProjectExists(projectGenerator.ProjectName))
{
CreateProject(generator, projectGeneratorType);
}
else if (!EnvDTEHelper.ProjectLoaded(projectGenerator.ProjectName))
{
//LoadProject(generator, projectGeneratorType);
//throw new Exception("The project '" + projectGenerator.ProjectName + "' is unloaded and cannot be generated.");
_errorList.Add("The project '" + projectGenerator.ProjectName + "' is unloaded and cannot be generated.");
return;
}
GenerateProjectItems(projectGenerator);
}
catch (Exception ex)
{
throw;
}
}
private void TestConnection(bool showMessage)
{
if (string.IsNullOrWhiteSpace(builder.DataSource))
{
return;
}
try
{
if (createDb)
{
if (!System.IO.File.Exists(builder.DataSource))
{
var engineHelper = Helpers.DataConnectionHelper.CreateEngineHelper(DatabaseType.SQLite);
engineHelper.CreateDatabase(builder.ConnectionString);
}
}
using (var conn = new SQLiteConnection(builder.ConnectionString))
{
conn.Open();
this.ConnectionString = builder.ConnectionString;
if (showMessage)
{
EnvDTEHelper.ShowMessage("Test succeeded!");
}
else
{
this.DialogResult = true;
}
}
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, DatabaseType.SQLite, false);
}
}
public void EditTableData(object sender, ExecutedRoutedEventArgs e)
{
string sqlText = null;
var menuInfo = ValidateMenuInfo(sender);
if (menuInfo == null)
{
return;
}
bool dbProviderPresent = menuInfo.DatabaseInfo.DatabaseType == DatabaseType.SQLCE35 && Helpers.DataConnectionHelper.IsV35DbProviderInstalled();
if (menuInfo.DatabaseInfo.DatabaseType == DatabaseType.SQLCE40 && Helpers.DataConnectionHelper.IsV40DbProviderInstalled())
{
dbProviderPresent = true;
}
if (menuInfo.DatabaseInfo.DatabaseType == DatabaseType.SQLite)
{
dbProviderPresent = true;
}
if (!dbProviderPresent)
{
EnvDTEHelper.ShowError("The required DbProvider registration is not present, please re-install/repair the SQL Server Compact runtime");
return;
}
try
{
bool readOnly = false;
List <int> readOnlyColumns = new List <int>();
using (IRepository repository = Helpers.DataConnectionHelper.CreateRepository(menuInfo.DatabaseInfo))
{
List <PrimaryKey> pks = repository.GetAllPrimaryKeys();
var tpks = repository.GetAllPrimaryKeys().Where(pk => pk.TableName == menuInfo.Name).ToList();
if (tpks.Count == 0)
{
readOnly = true;
}
List <Column> cols = repository.GetAllColumns();
cols = cols.Where(c => c.TableName == menuInfo.Name).ToList();
int x = 0;
foreach (Column col in cols)
{
if (col.AutoIncrementBy > 0 || col.RowGuidCol)
{
readOnlyColumns.Add(x);
}
x++;
}
var generator = Helpers.DataConnectionHelper.CreateGenerator(repository, menuInfo.DatabaseInfo.DatabaseType);
generator.GenerateTableSelect(menuInfo.Name);
sqlText = generator.GeneratedScript.Replace(";" + Environment.NewLine + "GO", "");
sqlText = sqlText.Replace(";" + Environment.NewLine, "");
if (menuInfo.DatabaseInfo.DatabaseType == DatabaseType.SQLite)
{
sqlText = sqlText + string.Format(" LIMIT {0}", Properties.Settings.Default.MaxRowsToEdit);
}
else
{
sqlText = sqlText.Replace(Environment.NewLine + "SELECT ", string.Format(Environment.NewLine + "SELECT TOP({0}) ", Properties.Settings.Default.MaxRowsToEdit));
}
}
var pkg = ParentWindow.Package as SqlCeToolboxPackage;
Debug.Assert(pkg != null, "Package property of the Explorere Tool Window should never be null, have you tried to create it manually and not through FindToolWindow()?");
string dbName = System.IO.Path.GetFileNameWithoutExtension(menuInfo.DatabaseInfo.Caption);
var window = pkg.CreateWindow <DataGridViewWindow>(Math.Abs(menuInfo.Name.GetHashCode() - dbName.GetHashCode()));
window.Caption = menuInfo.Name + " (" + dbName + ")";
pkg.ShowWindow(window);
var control = window.Content as DataEditControl;
control.DatabaseInfo = menuInfo.DatabaseInfo;
control.TableName = menuInfo.Name;
control.ReadOnly = readOnly;
control.ReadOnlyColumns = readOnlyColumns;
control.SqlText = sqlText;
control.ShowGrid();
DataConnectionHelper.LogUsage("TableEdit");
}
catch (Exception ex)
{
DataConnectionHelper.SendError(ex, menuInfo.DatabaseInfo.DatabaseType, false);
}
}
public void SyncFxGenerateLocalDatabaseCacheCode(object sender, ExecutedRoutedEventArgs e)
{
// http://www.mztools.com/articles/2007/MZ2007011.aspx
var menuItem = sender as MenuItem;
if (menuItem == null)
{
return;
}
Scope scope = (Scope)menuItem.Tag;
var dte = package.GetServiceHelper(typeof(EnvDTE.DTE)) as EnvDTE.DTE;
var dteH = new Helpers.EnvDTEHelper();
var project = dteH.GetProject(dte);
if (project == null)
{
EnvDTEHelper.ShowError("Please select a project in Solution Explorer, where you want the SyncFx classes to be placed");
return;
}
if (!dteH.AllowedProjectKinds.Contains(new Guid(project.Kind)))
{
EnvDTEHelper.ShowError("The selected project type does not support Sync Framework (please let me know if I am wrong)");
return;
}
if (project.CodeModel.Language != CodeModelLanguageConstants.vsCMLanguageCSharp)
{
EnvDTEHelper.ShowError("Unsupported code language, only C# is currently supported");
return;
}
if (project.Properties.Item("TargetFrameworkMoniker") == null)
{
EnvDTEHelper.ShowError("The selected project type does not support Sync Framework - missing TargetFrameworkMoniker");
return;
}
if (!project.Properties.Item("TargetFrameworkMoniker").Value.ToString().Contains(".NETFramework"))
{
EnvDTEHelper.ShowError("The selected project type does not support .NET Desktop - wrong TargetFrameworkMoniker: " + project.Properties.Item("TargetFrameworkMoniker").Value.ToString());
return;
}
try
{
string serverConnectionString = DataConnectionHelper.PromptForConnectionString(package);
if (!string.IsNullOrEmpty(serverConnectionString))
{
string clientConnectionString = string.Empty;
//grab target SQL CE Database
var dialog = new ConnectionDialog();
dialog.DbType = DatabaseType.SQLCE35;
bool?result = dialog.ShowModal();
if (result.HasValue && result.Value == true && !string.IsNullOrWhiteSpace(dialog.ConnectionString))
{
clientConnectionString = dialog.ConnectionString;
}
else
{
return;
}
string model = string.Empty;
SyncFxDialog sfd = new SyncFxDialog();
int totalCount = 0;
var databaseInfo = new DatabaseMenuCommandParameters
{
DatabaseInfo = new DatabaseInfo
{
ConnectionString = serverConnectionString,
DatabaseType = DatabaseType.SQLServer
}
};
totalCount = SyncFxGetObjectsForSync(sfd, databaseInfo);
sfd.ModelName = model;
bool?res = sfd.ShowModal();
if (res.HasValue && res.Value == true && (sfd.Tables.Count > 0) && !string.IsNullOrWhiteSpace(sfd.ModelName))
{
model = sfd.ModelName;
var defaultNamespace = project.Properties.Item("DefaultNamespace").Value.ToString();
var columns = sfd.Columns.Where(c => sfd.Tables.Contains(c.TableName)).ToList();
var classes = new SyncFxHelper().GenerateCodeForScope(serverConnectionString, clientConnectionString, "SQL", model, columns, defaultNamespace);
var projectPath = project.Properties.Item("FullPath").Value.ToString();
foreach (var item in classes)
{
string fileName = Path.Combine(projectPath, item.Key + ".cs");
if (File.Exists(fileName))
{
File.Delete(fileName);
}
File.WriteAllText(fileName, item.Value);
project.ProjectItems.AddFromFile(fileName);
}
//Adding references - http://blogs.msdn.com/b/murat/archive/2008/07/30/envdte-adding-a-refernce-to-a-project.aspx
EnvDTEHelper.AddReference(project, "System.Data.SqlServerCe, Version=3.5.1.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91");
EnvDTEHelper.AddReference(project, "Microsoft.Synchronization, Version=2.1.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91");
EnvDTEHelper.AddReference(project, "Microsoft.Synchronization.Data, Version=3.1.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91");
EnvDTEHelper.AddReference(project, "Microsoft.Synchronization.Data.SqlServer, Version=3.1.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91");
EnvDTEHelper.AddReference(project, "Microsoft.Synchronization.Data.SqlServerCe, Version=3.1.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91");
EnvDTEHelper.ShowMessage("Scope: " + model + " code generated.");
Helpers.DataConnectionHelper.LogUsage("DatabasesSyncAddLocalDBCache");
}
}
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, DatabaseType.SQLServer);
}
}
public void DesignDatabase(object sender, ExecutedRoutedEventArgs e)
{
EnvDTEHelper.LaunchUrl("http://sqlcompact.dk/sqldesigner/");
}
public void ScriptServerDatabase(object sender, ExecutedRoutedEventArgs e)
{
var menuItem = sender as MenuItem;
if (menuItem == null)
{
return;
}
Scope scope = (Scope)menuItem.Tag;
var databaseInfo = menuItem.CommandParameter as DatabaseMenuCommandParameters;
if (databaseInfo == null)
{
return;
}
try
{
string connectionString = databaseInfo.DatabaseInfo != null
? databaseInfo.DatabaseInfo.ConnectionString :
DataConnectionHelper.PromptForConnectionString(package);
if (!string.IsNullOrEmpty(connectionString))
{
string fileName;
PickTablesDialog ptd = new PickTablesDialog();
int totalCount = 0;
using (IRepository repository = Helpers.DataConnectionHelper.CreateRepository(new DatabaseInfo {
ConnectionString = connectionString, DatabaseType = DatabaseType.SQLServer
}))
{
ptd.Tables = repository.GetAllTableNamesForExclusion();
totalCount = ptd.Tables.Count;
}
bool?res = ptd.ShowModal();
if (res.HasValue && res.Value == true && (ptd.Tables.Count < totalCount))
{
SaveFileDialog fd = new SaveFileDialog();
fd.Title = "Save generated database script as";
fd.Filter = "SQL Server Compact Script (*.sqlce)|*.sqlce|SQL Server Script (*.sql)|*.sql|All Files(*.*)|*.*";
if (scope == Scope.SchemaDataSQLite || scope == Scope.SchemaSQLite)
{
fd.Filter = "SQL Script (*.sql)|*.sql|All Files(*.*)|*.*";
}
fd.OverwritePrompt = true;
fd.ValidateNames = true;
bool?result = fd.ShowDialog();
if (result.HasValue && result.Value == true)
{
fileName = fd.FileName;
using (IRepository repository = Helpers.DataConnectionHelper.CreateRepository(new DatabaseInfo {
ConnectionString = connectionString, DatabaseType = DatabaseType.SQLServer
}))
{
try
{
var generator = Helpers.DataConnectionHelper.CreateGenerator(repository, fd.FileName, DatabaseType.SQLServer);
generator.ExcludeTables(ptd.Tables);
EnvDTEHelper.ShowMessage(generator.ScriptDatabaseToFile(scope));
Helpers.DataConnectionHelper.LogUsage("DatabasesScriptServer");
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, DatabaseType.SQLServer, false);
}
}
}
}
}
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, DatabaseType.SQLServer, false);
}
}
private bool TestConnection(bool showMessage)
{
try
{
if (_createDb)
{
if (!System.IO.File.Exists(dataSourceTextBox.Text))
{
var engineHelper = DataConnectionHelper.CreateEngineHelper(DbType);
engineHelper.CreateDatabase(_connectionString);
}
}
using (DataConnectionHelper.CreateRepository(new DatabaseInfo {
ConnectionString = _connectionString, DatabaseType = DbType
}))
{
if (showMessage)
{
EnvDTEHelper.ShowMessage("Connection OK!");
}
else
{
DialogResult = true;
}
}
return(true);
}
catch (Exception ex)
{
if (ex.Message.Contains("Please upgrade using SqlCeEngine.Upgrade() method") && DbType == DatabaseType.SQLCE40)
{
if (EnvDTEHelper.ShowMessageBox("This database file is from an earlier version,\n\rwould you like to Upgrade it?\n\r(A copy of the original file will be named .bak)"
, Microsoft.VisualStudio.Shell.Interop.OLEMSGBUTTON.OLEMSGBUTTON_YESNO
, Microsoft.VisualStudio.Shell.Interop.OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_SECOND
, Microsoft.VisualStudio.Shell.Interop.OLEMSGICON.OLEMSGICON_WARNING) == System.Windows.Forms.DialogResult.Yes)
{
var bakFile = dataSourceTextBox.Text + ".bak";
var go = true;
try
{
if (System.IO.File.Exists(bakFile))
{
if (EnvDTEHelper.ShowMessageBox(string.Format("{0} already exists, do you wish to overwrite it?", bakFile)
, Microsoft.VisualStudio.Shell.Interop.OLEMSGBUTTON.OLEMSGBUTTON_YESNO
, Microsoft.VisualStudio.Shell.Interop.OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_SECOND
, Microsoft.VisualStudio.Shell.Interop.OLEMSGICON.OLEMSGICON_WARNING) == System.Windows.Forms.DialogResult.Yes)
{
System.IO.File.Delete(bakFile);
}
else
{
go = false;
}
}
if (go)
{
System.IO.File.Copy(dataSourceTextBox.Text, dataSourceTextBox.Text + ".bak");
var helper = new SqlCeScripting.SqlCeHelper4();
helper.UpgradeTo40(_connectionString);
DialogResult = true;
}
}
catch (Exception ex2)
{
DataConnectionHelper.SendError(ex2, DbType, false);
return(false);
}
}
}
else
{
DataConnectionHelper.SendError(ex, DbType, false);
return(false);
}
}
return(true);
}
private void DDEXButton_Click(object sender, RoutedEventArgs e)
{
Helpers.DataConnectionHelper.RegisterDDEXProviders(true);
EnvDTEHelper.ShowMessage("Providers registered, you may have to restart Visual Studio");
}
private void projectItemGenerator_ProjectItemGenerated(object sender, ProjectItemGeneratedEventArgs e)
{
//.NET is a single-threaded application so we much release to let the UI refresh sometimes.
if (_doEventCount % 10 == 0)
{
Application.DoEvents();
}
_doEventCount++;
try
{
const string solutionDirReplaceText = "$(solutiondir)";
if (e.FullName != null && e.FullName.ToLower().Contains(solutionDirReplaceText))
{
var ti = e.FullName.ToLower().IndexOf(solutionDirReplaceText);
e.FullName = e.FullName.Remove(ti, solutionDirReplaceText.Length).Insert(ti, EnvDTEHelper.Instance.SolutionDirectory.FullName);
}
if (e.ProjectItemName != null && e.ProjectItemName.ToLower().Contains(solutionDirReplaceText))
{
var ti = e.ProjectItemName.ToLower().IndexOf(solutionDirReplaceText);
e.ProjectItemName = e.ProjectItemName.Remove(ti, solutionDirReplaceText.Length).Insert(ti, EnvDTEHelper.Instance.SolutionDirectory.FullName);
}
//Get the parent project if one exists
Project project = null;
ProjectItem parent = null;
if (!string.IsNullOrEmpty(e.ProjectName))
{
if (projectCache.ContainsKey(e.ProjectName))
{
var p = projectCache[e.ProjectName];
//Test this COM object to ensure it has not expired.
//If error, do nothing and the project will be requeried
try
{
var s = p.Name;
project = p;
}
catch (Exception)
{
//Do Nothing
projectCache.Remove(e.ProjectName);
}
}
var fromCache = true;
if (project == null)
{
fromCache = false;
project = EnvDTEHelper.Instance.GetProject(e.ProjectName);
projectCache.Add(e.ProjectName, project);
}
parent = EnvDTEHelper.Instance.GetProjectItem(e.ProjectName, e.ParentItemName, e.ParentItemType);
//This should not happen. If do dump the cache project and requery
if (parent == null && fromCache)
{
if (projectCache.ContainsKey(e.ProjectName))
{
projectCache.Remove(e.ProjectName);
}
project = EnvDTEHelper.Instance.GetProject(e.ProjectName);
projectCache.Add(e.ProjectName, project);
parent = EnvDTEHelper.Instance.GetProjectItem(e.ProjectName, e.ParentItemName, e.ParentItemType);
}
}
var fileStateInfo = new FileStateInfo();
ProjectItem projectItem = null;
if (e.ParentItemName != string.Empty)
{
if (e.ContentType == ProjectItemContentType.String)
{
projectItem = EnvDTEHelper.Instance.AddProjectItem(project, parent, e.ProjectItemName, e.ProjectItemContent, e.Overwrite, out fileStateInfo);
}
else
{
projectItem = EnvDTEHelper.Instance.AddProjectItem(parent, e.ProjectItemContent, out fileStateInfo);
}
if (fileStateInfo.FileState == EnvDTEHelper.FileStateConstants.Success)
{
EnvDTEHelper.SetProperties(projectItem, e.Properties);
}
}
else
{
if (e.ContentType == ProjectItemContentType.String || e.ContentType == ProjectItemContentType.Binary)
{
if (project == null)
{
EnvDTEHelper.Instance.AddProjectItem(e.ProjectItemContent, e.ProjectItemBinaryContent, e.ContentType, e.ProjectItemName, e.Overwrite, out fileStateInfo);
}
else
{
projectItem = EnvDTEHelper.Instance.AddProjectItem(project, e.ProjectItemContent, e.ProjectItemBinaryContent, e.ContentType, e.ProjectItemName, e.Overwrite, out fileStateInfo);
}
}
else
{
projectItem = EnvDTEHelper.Instance.AddFileAsProjectItem(project, e.ProjectItemContent, e.ProjectItemName, e.Overwrite, out fileStateInfo);
}
if (fileStateInfo.FileState == EnvDTEHelper.FileStateConstants.Success)
{
EnvDTEHelper.SetProperties(projectItem, e.Properties);
}
}
//TEMP
processedFiles.Add(fileStateInfo.FileName);
//TEMP
//Custom Tool Functionality
if (e.RunCustomTool && projectItem != null)
{
if (!string.IsNullOrEmpty(e.CustomToolName))
{
EnvDTEHelper.SetProperty(projectItem, "Generator", e.CustomToolName);
EnvDTEHelper.SetProperty(projectItem, "CustomTool", e.CustomToolName);
}
//Try to run the custom tool
try
{
var vsProjectItem = projectItem.Object as VSLangProj.VSProjectItem;
if (vsProjectItem != null)
{
vsProjectItem.RunCustomTool();
}
}
catch
{
//Do Nothing
}
}
#region Compute CRC
//System.IO.StreamReader sr = System.IO.File.OpenText("");
//nHydrate.Generator.Common.Util.CRC32HashAlgorithm hash = new CRC32HashAlgorithm();
//byte[] arr = hash.ComputeHash(sr.BaseStream);
//sr.Close();
//XmlHelper.AddAttribute(newfileNode, "crc", "0");
#endregion
if (fileStateInfo.FileName == string.Empty)
{
System.Diagnostics.Debug.Write(string.Empty);
}
if (fileStateInfo.FileState == EnvDTEHelper.FileStateConstants.Failed)
{
System.Diagnostics.Debug.Write(string.Empty);
}
//Write Log
nHydrateLog.LogInfo("Project Item Generated: {0}", e.ProjectItemName);
e.FileState = fileStateInfo.FileState;
e.FullName = fileStateInfo.FileName;
this.OnProjectItemGenerated(sender, e);
}
catch (Exception ex)
{
this.OnProjectItemGeneratedError(this, e);
nHydrateLog.LogWarning(ex);
}
}
public void GenerateDataDiffScript(object sender, ExecutedRoutedEventArgs e)
{
try
{
var menuInfo = ValidateMenuInfo(sender);
var package = ParentWindow.Package as SqlCeToolboxPackage;
if (menuInfo == null)
{
return;
}
Dictionary <string, DatabaseInfo> databaseList = Helpers.DataConnectionHelper.GetDataConnections(package, true, false);
foreach (KeyValuePair <string, DatabaseInfo> info in Helpers.DataConnectionHelper.GetOwnDataConnections())
{
if (!databaseList.ContainsKey(info.Key))
{
databaseList.Add(info.Key, info.Value);
}
}
foreach (KeyValuePair <string, DatabaseInfo> info in databaseList)
{
string sourceType = string.Empty;
switch (info.Value.DatabaseType)
{
case DatabaseType.SQLCE35:
sourceType = "3.5";
break;
case DatabaseType.SQLCE40:
sourceType = "4.0";
break;
case DatabaseType.SQLServer:
sourceType = "Server";
break;
}
info.Value.Caption = string.Format("{0} ({1})", info.Value.Caption, sourceType);
}
CompareDialog cd = new CompareDialog(menuInfo.DatabaseInfo.Caption, databaseList, menuInfo.Name);
bool?result = cd.ShowModal();
if (result.HasValue && result.Value == true && (cd.TargetDatabase.Key != null))
{
var target = cd.TargetDatabase;
var source = new KeyValuePair <string, DatabaseInfo>(menuInfo.DatabaseInfo.ConnectionString, menuInfo.DatabaseInfo);
var editorTarget = target;
if (editorTarget.Value.DatabaseType == DatabaseType.SQLServer)
{
editorTarget = source;
}
using (IRepository sourceRepository = Helpers.DataConnectionHelper.CreateRepository(source.Value))
{
using (IRepository targetRepository = Helpers.DataConnectionHelper.CreateRepository(target.Value))
{
var generator = Helpers.DataConnectionHelper.CreateGenerator(targetRepository, target.Value.DatabaseType);
try
{
var script = SqlCeDiff.CreateDataDiffScript(sourceRepository, menuInfo.Name, targetRepository, menuInfo.Name, generator);
var sqlEditorWindow = package.CreateWindow <SqlEditorWindow>();
var editorControl = sqlEditorWindow.Content as SqlEditorControl;
editorControl.ExplorerControl = ParentWindow.Content as ExplorerControl;
Debug.Assert(editorControl != null);
editorControl.DatabaseInfo = editorTarget.Value;
editorControl.SqlText = script;
Helpers.DataConnectionHelper.LogUsage("TableScriptDataDiff");
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, source.Value.DatabaseType, false);
}
}
}
}
}
catch (ArgumentException ae)
{
EnvDTEHelper.ShowError(ae.Message);
}
catch (Exception ex)
{
Helpers.DataConnectionHelper.SendError(ex, DatabaseType.SQLCE35, false);
}
}
