public void GenerateServerDgmlFiles()
{
ThreadHelper.ThrowIfNotOnUIThread();
EnvDteHelper.ShowError("This feature is no longer supported, install SQLite Toolbox to get it back.");
return;
}
private List <TableInformationModel> GetTablesFromRepository(DatabaseInfo dbInfo)
{
if (dbInfo.DatabaseType == DatabaseType.Npgsql)
{
return(EnvDteHelper.GetNpgsqlTableNames(dbInfo.ConnectionString));
}
if (dbInfo.DatabaseType == DatabaseType.Mysql)
{
return(EnvDteHelper.GetMysqlTableNames(dbInfo.ConnectionString));
}
using (var repository = RepositoryHelper.CreateRepository(dbInfo))
{
var allPks = repository.GetAllPrimaryKeys();
var tableList = repository.GetAllTableNamesForExclusion();
var tables = new List <TableInformationModel>();
foreach (var table in tableList)
{
var hasPrimaryKey = allPks.Any(m => m.TableName == table);
tables.Add(new TableInformationModel(table, hasPrimaryKey));
}
return(tables);
}
}
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);
}
}
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 void SaveOptions(Project project, string optionsPath, ReverseEngineerOptions options, Tuple <List <Schema>, string> renamingOptions)
{
ThreadHelper.ThrowIfNotOnUIThread();
if (File.Exists(optionsPath) && File.GetAttributes(optionsPath).HasFlag(FileAttributes.ReadOnly))
{
EnvDteHelper.ShowError($"Unable to save options, the file is readonly: {optionsPath}");
return;
}
if (!File.Exists(optionsPath + ".ignore"))
{
File.WriteAllText(optionsPath, options.Write(), Encoding.UTF8);
project.ProjectItems.AddFromFile(optionsPath);
}
if (renamingOptions.Item1 != null && !File.Exists(renamingOptions.Item2 + ".ignore") && renamingOptions.Item1.Count() > 0)
{
if (File.Exists(renamingOptions.Item2) && File.GetAttributes(renamingOptions.Item2).HasFlag(FileAttributes.ReadOnly))
{
EnvDteHelper.ShowError($"Unable to save renaming options, the file is readonly: {renamingOptions.Item2}");
return;
}
File.WriteAllText(renamingOptions.Item2, CustomNameOptionsExtensions.Write(renamingOptions.Item1), Encoding.UTF8);
project.ProjectItems.AddFromFile(renamingOptions.Item2);
}
}
private void AddButton_OnClick(object sender, RoutedEventArgs e)
{
try
{
var info = EnvDteHelper.PromptForInfo(_package);
if (info.DatabaseType == DatabaseType.SQLCE35)
{
return;
}
var databaseList = EnvDteHelper.GetDataConnections(_package);
comboBox1.DisplayMemberPath = "Value.Caption";
comboBox1.ItemsSource = databaseList;
int i = 0;
foreach (var item in databaseList)
{
if (item.Key == info.ConnectionString)
{
comboBox1.SelectedIndex = i;
}
i++;
}
}
catch (Exception exception)
{
EnvDteHelper.ShowMessage(exception.ToString());
}
}
public async System.Threading.Tasks.Task ManageMigrationsAsync(string outputPath, Project project)
{
try
{
if (string.IsNullOrEmpty(outputPath))
{
throw new ArgumentException(outputPath, nameof(outputPath));
}
if (project == null)
{
throw new ArgumentNullException(nameof(project));
}
if (project.Properties.Item("TargetFrameworkMoniker") == null)
{
EnvDteHelper.ShowError("The selected project type has no TargetFrameworkMoniker");
return;
}
if (!project.IsNetCore30OrHigher())
{
EnvDteHelper.ShowError("Only .NET Core 3.0+ projects are supported - TargetFrameworkMoniker: " + project.Properties.Item("TargetFrameworkMoniker").Value);
return;
}
var outputFolder = Path.GetDirectoryName(outputPath);
var result = await project.ContainsEfCoreDesignReferenceAsync();
if (string.IsNullOrEmpty(result.Item2))
{
EnvDteHelper.ShowError("EF Core 3.1 or later not found in project");
return;
}
if (!result.Item1)
{
if (!Version.TryParse(result.Item2, out Version version))
{
EnvDteHelper.ShowError($"Cannot support version {version}, notice that previews are not supported.");
return;
}
var nugetHelper = new NuGetHelper();
nugetHelper.InstallPackage("Microsoft.EntityFrameworkCore.Design", project, version);
EnvDteHelper.ShowError($"Installing EFCore.Design version {version}, please retry the command");
return;
}
var migrationsDialog = _package.GetView <IMigrationOptionsDialog>();
migrationsDialog.UseProjectForMigration(project)
.UseOutputPath(outputPath);
migrationsDialog.ShowAndAwaitUserResponse(true);
}
catch (Exception exception)
{
_package.LogError(new List <string>(), exception);
}
}
public void AddCe40Database(object sender, ExecutedRoutedEventArgs e)
{
// http://www.mztools.com/articles/2007/MZ2007011.aspx
if (!DataConnectionHelper.DdexProviderIsInstalled(new Guid(Resources.SqlCompact40Provider)))
{
EnvDteHelper.ShowError("The version 4.0 Visual Studio DDEX provider is not installed, cannot add connection");
return;
}
try
{
var objIVsDataConnectionDialogFactory = _package.GetServiceHelper(typeof(IVsDataConnectionDialogFactory)) as IVsDataConnectionDialogFactory;
if (objIVsDataConnectionDialogFactory != null)
{
var objIVsDataConnectionDialog = objIVsDataConnectionDialogFactory.CreateConnectionDialog();
objIVsDataConnectionDialog.AddAllSources();
objIVsDataConnectionDialog.SelectedSource = new Guid("34A4B3E8-C54D-466F-92EA-E5814B97CA43");
objIVsDataConnectionDialog.SelectedProvider = new Guid(Resources.SqlCompact40Provider);
if (objIVsDataConnectionDialog.ShowDialog() && objIVsDataConnectionDialog.SelectedProvider == new Guid(Resources.SqlCompact40Provider))
{
DataConnectionHelper.SaveDataConnection(_package, objIVsDataConnectionDialog.EncryptedConnectionString, objIVsDataConnectionDialog.DisplayConnectionString, DatabaseType.SQLCE40, new Guid(Resources.SqlCompact40Provider));
var control = _parentWindow.Content as ExplorerControl;
control?.BuildDatabaseTree();
DataConnectionHelper.LogUsage("DatabasesAddCe40Database");
}
objIVsDataConnectionDialog.Dispose();
}
}
catch (Exception ex)
{
DataConnectionHelper.SendError(ex, DatabaseType.SQLCE40, false);
}
}
private bool SaveSettings()
{
try
{
TableName = 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);
PkScript = _dbType == DatabaseType.SQLite ? BuildSqLitePkScript(_columns.ToList(), TableName) : TableColumn.BuildPkScript(_columns.ToList(), TableName);
return(true);
}
catch (Exception ex)
{
DataConnectionHelper.SendError(ex, DatabaseType.SQLServer);
}
return(false);
}
private DatabaseConnectionModel GetDatabaseInfo(ReverseEngineerOptions options)
{
ThreadHelper.ThrowIfNotOnUIThread();
var dbInfo = new DatabaseConnectionModel();
if (!string.IsNullOrEmpty(options.ConnectionString))
{
dbInfo.ConnectionString = options.ConnectionString;
dbInfo.DatabaseType = options.DatabaseType;
}
if (!string.IsNullOrEmpty(options.Dacpac))
{
dbInfo.DatabaseType = DatabaseType.SQLServerDacpac;
dbInfo.ConnectionString = $"Data Source=(local);Initial Catalog={Path.GetFileNameWithoutExtension(options.Dacpac)};Integrated Security=true;";
options.ConnectionString = dbInfo.ConnectionString;
options.DatabaseType = dbInfo.DatabaseType;
options.Dacpac = _package.Dte2.DTE.BuildSqlProj(options.Dacpac);
if (string.IsNullOrEmpty(options.Dacpac))
{
EnvDteHelper.ShowMessage(ReverseEngineerLocale.UnableToBuildSelectedDatabaseProject);
return(null);
}
}
if (dbInfo.DatabaseType == DatabaseType.Undefined)
{
EnvDteHelper.ShowError($"{ReverseEngineerLocale.UnsupportedProvider}");
return(null);
}
return(dbInfo);
}
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 async System.Threading.Tasks.Task ReverseEngineerCodeFirstAsync(Project project)
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
if (_package.Dte2.Mode == vsIDEMode.vsIDEModeDebug)
{
EnvDteHelper.ShowError("Cannot generate code while debugging");
return;
}
var projectPath = project.Properties.Item("FullPath")?.Value.ToString();
var optionsPaths = project.GetConfigFiles();
var optionsPath = optionsPaths.First();
if (optionsPaths.Count > 1)
{
var pcd = _package.GetView <IPickConfigDialog>();
pcd.PublishConfigurations(optionsPaths.Select(m => new ConfigModel
{
ConfigPath = m,
ProjectPath = projectPath
}));
var pickConfigResult = pcd.ShowAndAwaitUserResponse(true);
if (!pickConfigResult.ClosedByOK)
{
return;
}
optionsPath = pickConfigResult.Payload.ConfigPath;
}
await ReverseEngineerCodeFirstAsync(project, optionsPath, false);
}
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 = _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);
}
public static List <string> GenerateFiles(this Project project, List <Tuple <string, string> > result, string extension)
{
var list = new List <string>();
foreach (var item in result)
{
if (item.Item1.IndexOfAny(Path.GetInvalidPathChars()) >= 0 ||
item.Item1.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0)
{
EnvDteHelper.ShowError("Invalid name: " + item.Item1);
return(list);
}
var filePath = Path.Combine(Path.GetTempPath(),
item.Item1 + extension);
if (File.Exists(filePath))
{
File.SetAttributes(filePath, FileAttributes.Normal);
}
File.WriteAllText(filePath, item.Item2);
File.SetAttributes(filePath, FileAttributes.ReadOnly);
list.Add(filePath);
}
return(list);
}
public void SyncFxDeprovisionDatabase(object sender, ExecutedRoutedEventArgs e)
{
var databaseInfo = ValidateMenuInfo(sender);
if (databaseInfo == null)
{
return;
}
if (databaseInfo.DatabaseInfo.DatabaseType != DatabaseType.SQLCE35)
{
EnvDteHelper.ShowError("Sorry, only version 3.5 databases are supported for now");
return;
}
if (!SyncFxHelper.IsProvisioned(databaseInfo.DatabaseInfo))
{
EnvDteHelper.ShowError("The database is not provisioned, cannot deprovision");
return;
}
try
{
new SyncFxHelper().DeprovisionDatabase(databaseInfo.DatabaseInfo.ConnectionString);
databaseInfo.ExplorerControl.RefreshTables(databaseInfo.DatabaseInfo);
EnvDteHelper.ShowMessage("Database deprovisioned");
DataConnectionHelper.LogUsage("DatabaseSyncDeprovision");
}
catch (Exception ex)
{
DataConnectionHelper.SendError(ex, databaseInfo.DatabaseInfo.DatabaseType, false);
}
}
private void ReportRevEngErrors(EfCoreReverseEngineerResult revEngResult, string missingProviderPackage)
{
var errors = new StringBuilder();
foreach (var entityError in revEngResult.EntityErrors)
{
errors.Append($"Table: {entityError.Key}{Environment.NewLine}");
errors.Append($"Error: {entityError.Value}{Environment.NewLine}");
}
if (revEngResult.EntityErrors.Count == 0)
{
errors.Insert(0, "Model generated successfully." + Environment.NewLine);
}
else
{
errors.Insert(0, "The following issues were encountered:" + Environment.NewLine);
}
if (!string.IsNullOrEmpty(missingProviderPackage))
{
errors.AppendLine();
errors.AppendFormat("The \"{0}\" NuGet package was not found in the project - it must be installed in order to build.", missingProviderPackage);
}
EnvDteHelper.ShowMessage(errors.ToString());
}
internal void LogError(List <string> statusMessages, Exception exception)
{
ThreadHelper.JoinableTaskFactory.Run(async delegate {
// Switch to main thread
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
_dte2.StatusBar.Text = "An error occurred. See the Output window for details.";
try
{
var buildOutputWindow = _dte2.ToolWindows.OutputWindow.OutputWindowPanes.Item("Build");
buildOutputWindow.OutputString(Environment.NewLine);
foreach (var error in statusMessages)
{
buildOutputWindow.OutputString(error + Environment.NewLine);
}
if (exception != null)
{
buildOutputWindow.OutputString(exception + Environment.NewLine);
}
buildOutputWindow.Activate();
}
catch
{
EnvDteHelper.ShowError(exception.ToString());
}
});
}
private async Task GetMigrationStatus()
{
try
{
StartAnimation();
_package.Dte2.StatusBar.Text = "Getting Migration Status";
if (_project.TryBuild())
{
var processResult = await _processLauncher.GetOutputAsync(_outputPath, GenerationType.MigrationStatus, null);
ReportStatus(processResult);
}
else
{
EnvDteHelper.ShowError("Build failed");
}
}
catch (Exception ex)
{
EnvDteHelper.ShowError(ex.ToString());
}
finally
{
_package.Dte2.StatusBar.Text = string.Empty;
StopAnimation();
}
}
private async void Window_Loaded(object sender, RoutedEventArgs e)
{
cmbDbContext.IsEnabled = false;
imgUnicorn.Opacity = 0;
txtMigrationName.Visibility = Visibility.Collapsed;
lblMigration.Visibility = Visibility.Collapsed;
btnApply.Visibility = Visibility.Collapsed;
var image = new Image();
var thisassembly = Assembly.GetExecutingAssembly();
var imageStream = thisassembly.GetManifestResourceStream("EFCorePowerTools.Resources.Unicorn.png");
var bmp = BitmapFrame.Create(imageStream);
image.Source = bmp;
imgUnicorn.ImageSource = image.Source;
await GetMigrationStatus();
if (cmbDbContext.Items.Count == 0)
{
EnvDteHelper.ShowMessage("No valid DbContext classes found in the current project");
Close();
}
cmbDbContext.IsEnabled = true;
}
public void AddCe35Database(object sender, ExecutedRoutedEventArgs e)
{
// http://www.mztools.com/articles/2007/MZ2007011.aspx
if (!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;
if (objIVsDataConnectionDialogFactory == null)
{
return;
}
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))
{
DataConnectionHelper.SaveDataConnection(_package, objIVsDataConnectionDialog.EncryptedConnectionString, DatabaseType.SQLCE35, new Guid(Resources.SqlCompact35Provider));
var control = _parentWindow.Content as ExplorerControl;
control?.BuildDatabaseTree();
DataConnectionHelper.LogUsage("DatabasesAddCe35Database");
}
objIVsDataConnectionDialog.Dispose();
}
catch (Exception ex)
{
DataConnectionHelper.SendError(ex, DatabaseType.SQLCE35);
}
}
internal void LogError(List <string> statusMessages, Exception exception)
{
_dte2.StatusBar.Text = "An error occurred. See the Output window for details.";
try
{
var buildOutputWindow = _dte2.ToolWindows.OutputWindow.OutputWindowPanes.Item("Build");
buildOutputWindow.OutputString(Environment.NewLine);
foreach (var error in statusMessages)
{
buildOutputWindow.OutputString(error + Environment.NewLine);
}
if (exception != null)
{
buildOutputWindow.OutputString(exception + Environment.NewLine);
}
buildOutputWindow.Activate();
}
catch
{
EnvDteHelper.ShowError(exception.ToString());
}
}
private void GenerateDgml(List <Tuple <string, string> > modelResult, Project project)
{
var dgmlBuilder = new DgmlBuilder.DgmlBuilder();
ProjectItem item = null;
foreach (var info in modelResult)
{
var dgmlText = dgmlBuilder.Build(info.Item2, info.Item1, GetTemplate());
if (info.Item1.IndexOfAny(Path.GetInvalidPathChars()) >= 0 ||
info.Item1.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0)
{
EnvDteHelper.ShowError("Invalid name: " + info.Item1);
return;
}
var path = Path.Combine(Path.GetTempPath(), info.Item1 + ".dgml");
File.WriteAllText(path, dgmlText, Encoding.UTF8);
item = project.ProjectItems.GetItem(Path.GetFileName(path));
if (item != null)
{
item.Delete();
}
item = project.ProjectItems.AddFromFileCopy(path);
}
if (item != null)
{
var window = item.Open();
window.Document.Activate();
}
}
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 void ReportTableData(object sender, ExecutedRoutedEventArgs e)
{
string sqlText;
var menuItem = sender as MenuItem;
var ds = new DataSet();
var menuInfo = menuItem?.CommandParameter as MenuCommandParameters;
if (menuInfo == null)
{
return;
}
try
{
using (var repository = Helpers.RepositoryHelper.CreateRepository(menuInfo.DatabaseInfo))
{
var generator = DataConnectionHelper.CreateGenerator(repository, menuInfo.DatabaseInfo.DatabaseType);
generator.GenerateViewSelect(menuInfo.Name);
OpenSqlEditorToolWindow(menuInfo, generator.GeneratedScript);
sqlText = Environment.NewLine + generator.GeneratedScript
+ 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);
if (dbName != null)
{
var window = pkg.CreateWindow <ReportWindow>(Math.Abs(menuInfo.Name.GetHashCode() - dbName.GetHashCode()));
if (window == null)
{
return;
}
window.Caption = menuInfo.Name + " (" + dbName + ")";
pkg.ShowWindow(window);
var control = window.Content as ReportControl;
if (control != null)
{
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();
}
public void GenerateServerDgmlFiles()
{
try
{
if (_package.Dte2.Mode == vsIDEMode.vsIDEModeDebug)
{
EnvDteHelper.ShowError("Cannot generate code while debugging");
return;
}
// Show dialog with SqlClient selected by default
var dialogFactory = _package.GetService <IVsDataConnectionDialogFactory>();
var dialog = dialogFactory.CreateConnectionDialog();
dialog.AddAllSources();
dialog.SelectedSource = new Guid("067ea0d9-ba62-43f7-9106-34930c60c528");
var dialogResult = dialog.ShowDialog(connect: true);
if (dialogResult == null)
{
return;
}
_package.Dte2.StatusBar.Text = "Loading schema information...";
var dbInfo = GetDatabaseInfo(dialogResult, DataProtection.DecryptString(dialog.EncryptedConnectionString));
if (dbInfo.DatabaseType == DatabaseType.SQLCE35)
{
EnvDteHelper.ShowError($"Unsupported provider: {dbInfo.ServerVersion}");
return;
}
var ptd = new PickTablesDialog();
using (var repository = RepositoryHelper.CreateRepository(dbInfo))
{
ptd.Tables = repository.GetAllTableNamesForExclusion();
}
var res = ptd.ShowModal();
if (!res.HasValue || !res.Value)
{
return;
}
var path = Path.GetTempFileName() + ".dgml";
using (var repository = RepositoryHelper.CreateRepository(dbInfo))
{
var generator = RepositoryHelper.CreateGenerator(repository, path, dbInfo.DatabaseType);
generator.GenerateSchemaGraph(dbInfo.ConnectionString, ptd.Tables);
_package.Dte2.ItemOperations.OpenFile(path);
_package.Dte2.ActiveDocument.Activate();
}
}
catch (Exception ex)
{
_package.LogError(new List <string>(), ex);
}
}
public void RemoveDatabaseConnection(object sender, ExecutedRoutedEventArgs e)
{
try
{
var databaseInfo = ValidateMenuInfo(sender);
if (databaseInfo == null)
{
return;
}
if (databaseInfo.DatabaseInfo.FromServerExplorer)
{
bool providerInstalled = true;
var provider = new Guid(Resources.SqlCompact40Provider);
if (databaseInfo.DatabaseInfo.DatabaseType == DatabaseType.SQLCE35)
{
provider = new Guid(Resources.SqlCompact35Provider);
}
if (databaseInfo.DatabaseInfo.DatabaseType == DatabaseType.SQLite)
{
provider = new Guid(Resources.SqlitePrivateProvider);
}
providerInstalled = DataConnectionHelper.DdexProviderIsInstalled(provider);
if (!providerInstalled)
{
if (databaseInfo.DatabaseInfo.DatabaseType == DatabaseType.SQLCE40)
{
provider = new Guid(Resources.SqlCompact40PrivateProvider);
providerInstalled = DataConnectionHelper.DdexProviderIsInstalled(provider);
}
if (!providerInstalled)
{
EnvDteHelper.ShowError("The DDEX provider is not installed, cannot remove connection");
return;
}
}
DataConnectionHelper.RemoveDataConnection(package, databaseInfo.DatabaseInfo.ConnectionString, provider);
}
else
{
DataConnectionHelper.RemoveDataConnection(databaseInfo.DatabaseInfo.ConnectionString);
}
var control = _parentWindow.Content as ExplorerControl;
if (control != null)
{
control.BuildDatabaseTree();
}
DataConnectionHelper.LogUsage("DatabaseRemoveCe");
}
catch (Exception ex)
{
DataConnectionHelper.SendError(ex, DatabaseType.SQLCE35);
}
}
public void Generate(string outputPath, Project project, GenerationType generationType)
{
try
{
if (string.IsNullOrEmpty(outputPath))
{
throw new ArgumentException(outputPath, nameof(outputPath));
}
if (project.Properties.Item("TargetFrameworkMoniker") == null)
{
EnvDteHelper.ShowError("The selected project type has no TargetFrameworkMoniker");
return;
}
if (!project.Properties.Item("TargetFrameworkMoniker").Value.ToString().Contains(".NETFramework") &&
!project.Properties.Item("TargetFrameworkMoniker").Value.ToString().Contains(".NETCoreApp,Version=v2.0"))
{
EnvDteHelper.ShowError("Currently only .NET Framework and .NET Core 2.0 projects are supported - TargetFrameworkMoniker: " + project.Properties.Item("TargetFrameworkMoniker").Value);
return;
}
bool isNetCore = project.Properties.Item("TargetFrameworkMoniker").Value.ToString().Contains(".NETCoreApp,Version=v2.0");
var processResult = _processLauncher.GetOutput(outputPath, isNetCore, generationType);
if (processResult.StartsWith("Error:"))
{
throw new ArgumentException(processResult, nameof(processResult));
}
switch (generationType)
{
case GenerationType.Dgml:
GenerateDgml(processResult, project);
Telemetry.TrackEvent("PowerTools.GenerateModelDgml");
break;
case GenerationType.Ddl:
GenerateFiles(processResult, project, ".sql");
Telemetry.TrackEvent("PowerTools.GenerateSqlCreate");
break;
case GenerationType.DebugView:
GenerateFiles(processResult, project, ".txt");
Telemetry.TrackEvent("PowerTools.GenerateDebugView");
break;
default:
break;
}
}
catch (Exception exception)
{
_package.LogError(new List <string>(), exception);
}
}
public void GenerateServerDgmlFiles()
{
try
{
if (_package.Dte2.Mode == vsIDEMode.vsIDEModeDebug)
{
EnvDteHelper.ShowError("Cannot generate code while debugging");
return;
}
var databaseList = EnvDteHelper.GetDataConnections(_package);
var psd = new PickServerDatabaseDialog(databaseList, _package);
var diagRes = psd.ShowModal();
if (!diagRes.HasValue || !diagRes.Value)
{
return;
}
_package.Dte2.StatusBar.Text = "Loading schema information...";
var dbInfo = psd.SelectedDatabase.Value;
if (dbInfo.DatabaseType == DatabaseType.SQLCE35)
{
EnvDteHelper.ShowError($"Unsupported provider: {dbInfo.ServerVersion}");
return;
}
var ptd = new PickTablesDialog();
using (var repository = RepositoryHelper.CreateRepository(dbInfo))
{
ptd.Tables = repository.GetAllTableNamesForExclusion();
}
var res = ptd.ShowModal();
if (!res.HasValue || !res.Value)
{
return;
}
var path = Path.GetTempFileName() + ".dgml";
using (var repository = RepositoryHelper.CreateRepository(dbInfo))
{
var generator = RepositoryHelper.CreateGenerator(repository, path, dbInfo.DatabaseType);
generator.GenerateSchemaGraph(dbInfo.ConnectionString, ptd.Tables);
_package.Dte2.ItemOperations.OpenFile(path);
_package.Dte2.ActiveDocument.Activate();
}
Telemetry.TrackEvent("PowerTools.GenerateSchemaDgml");
}
catch (Exception ex)
{
_package.LogError(new List <string>(), ex);
}
}
DatabaseDefinitionModel IVisualStudioAccess.PromptForNewDatabaseDefinition()
{
var fileName = EnvDteHelper.PromptForDacpac();
return(new DatabaseDefinitionModel
{
FilePath = fileName,
});
}
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);
}
}
