/// <summary> /// Generates SQL post deployment script that pushes R code into a table /// as well as /// </summary> private void CreatePostDeploymentScriptFile(SqlSProcPublishSettings settings, EnvDTE.Project targetProject, string targetFolder, EnvDTE.ProjectItem targetProjectItem, SProcMap sprocMap) { var postDeploymentScript = Path.Combine(targetFolder, PostDeploymentScriptName); var g = new SProcScriptGenerator(_fs); var script = g.CreatePostDeploymentScript(settings, sprocMap); _fs.WriteAllText(postDeploymentScript, script); var item = targetProjectItem.ProjectItems.AddFromFile(postDeploymentScript); item.Properties.Item("BuildAction").Value = "PostDeploy"; }
/// <summary> /// Creates code for stored procedures /// </summary> public SProcMap CreateStoredProcedureScripts(SqlSProcPublishSettings settings, IEnumerable <string> sprocFiles) { var sprocMap = new SProcMap(); foreach (var rFilePath in sprocFiles) { var sprocName = _fs.GetSProcNameFromTemplate(rFilePath); if (!string.IsNullOrEmpty(sprocName)) { string template; if (settings.CodePlacement == RCodePlacement.Inline) { template = FillSprocInlineTemplate(rFilePath, sprocName); } else { template = FillSprocTableTemplate(rFilePath, sprocName, settings.TableName, settings.QuoteType); } if (!string.IsNullOrEmpty(template)) { sprocMap[sprocName] = template; } } } return(sprocMap); }
public void PublishDacpac(string rFile) { var fs = new FileSystem(); var settings = new SqlSProcPublishSettings(); settings.TargetType = PublishTargetType.Dacpac; SetupProjectMocks("project.rproj"); var builder = Substitute.For<IDacPacBuilder>(); builder.When(x => x.Build(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<string>>())).Do(c => { c.Args()[0].Should().Be("project.dacpac"); c.Args()[1].Should().Be("project"); var e = c.Args()[2] as IEnumerable<string>; e.Should().HaveCount(1); e.First().Should().StartWith("CREATE PROCEDURE ProcName"); }); _dacServices.GetBuilder().Returns(builder); var files = new string[] { Path.Combine(_files.DestinationPath, rFile) }; var publisher = new SProcPublisher(_appShell, _pss, fs, _dacServices); publisher.Publish(settings, files); builder.Received(1).Build(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<string>>()); }
/// <summary> /// Packages stored procedures into a DACPAC. /// </summary> private void PublishToDacPac(SqlSProcPublishSettings settings, IEnumerable <string> sprocFiles) { var project = _pss.GetSelectedProject <IVsHierarchy>()?.GetDTEProject(); var dacpacPath = Path.ChangeExtension(project.FullName, DacPacExtension); CreateDacPac(settings, sprocFiles, dacpacPath); RtvsTelemetry.Current?.TelemetryService.ReportEvent(TelemetryArea.SQL, SqlTelemetryEvents.SqlDacPacPublish); }
private async Task InitializeModelAsync() { var settings = new SqlSProcPublishSettings(_settings); _model = await SqlPublishOptionsDialogViewModel.CreateAsync(settings, _shell, _pss, _pcsp); DataContext = _model; }
/// <summary> /// Generates SQL files for stored procedures as well as publishing scripts /// and then adds them to the target database project. /// </summary> private void PublishToProject(SqlSProcPublishSettings settings, IEnumerable <string> sprocFiles) { Check.ArgumentNull(nameof(settings), settings.TargetProject); var targetProject = _pss.GetProject(settings.TargetProject); var generator = new SProcProjectFilesGenerator(_pss, _fs); generator.Generate(settings, targetProject); RtvsTelemetry.Current?.TelemetryService.ReportEvent(TelemetryArea.SQL, SqlTelemetryEvents.SqlProjectPublish); }
/// <summary> /// Create SQL file that defines table template that will hold R code /// </summary> internal void CreateRCodeTableFile(SqlSProcPublishSettings settings, EnvDTE.Project targetProject, string targetFolder, EnvDTE.ProjectItem targetProjectItem) { var creatTableScriptFile = Path.Combine(targetFolder, CreateRCodeTableScriptName); var g = new SProcScriptGenerator(_fs); var script = g.CreateRCodeTableScript(settings); _fs.WriteAllText(creatTableScriptFile, script); targetProjectItem.ProjectItems.AddFromFile(creatTableScriptFile); }
private void CreateDacPac(SqlSProcPublishSettings settings, IEnumerable <string> sprocFiles, string dacpacPath) { var project = _pss.GetSelectedProject <IVsHierarchy>()?.GetDTEProject(); var g = new SProcScriptGenerator(_fs); var sprocMap = g.CreateStoredProcedureScripts(settings, sprocFiles); var builder = _dacServices.GetBuilder(_appShell); builder.Build(dacpacPath, project.Name, sprocMap.Scripts); }
/// <summary> /// Create SQL file that defines table template that will hold R code /// </summary> internal void CreateRCodeTableFile(SqlSProcPublishSettings settings, EnvDTE.Project targetProject, string targetFolder, EnvDTE.ProjectItem targetProjectItem) { var creatTableScriptFile = Path.Combine(targetFolder, CreateRCodeTableScriptName); var g = new SProcScriptGenerator(_fs); var script = g.CreateRCodeTableScript(settings); _fs.WriteAllText(creatTableScriptFile, script); targetProjectItem.ProjectItems.AddFromFile(creatTableScriptFile); }
private SqlPublishOptionsDialogViewModel(SqlSProcPublishSettings settings, ICoreShell coreShell, IProjectSystemServices pss, IProjectConfigurationSettingsProvider pcsp) { _coreShell = coreShell; _pss = pss; _pcsp = pcsp; Settings = settings; }
public static async Task <SqlPublishOptionsDialogViewModel> CreateAsync( SqlSProcPublishSettings settings, ICoreShell coreShell, IProjectSystemServices pss, IProjectConfigurationSettingsProvider pcsp) { var model = new SqlPublishOptionsDialogViewModel(settings, coreShell, pss, pcsp); await model.InitializeAsync(); return(model); }
public async Task SelectQuoteType() { var settings = new SqlSProcPublishSettings(_storage); var model = await SqlPublishOptionsDialogViewModel.CreateAsync(settings, _coreShell, _pss, _pcsp); model.SelectQuoteType(1); model.Settings.QuoteType.Should().Be(SqlQuoteType.Bracket); model.SelectQuoteType(2); model.Settings.QuoteType.Should().Be(SqlQuoteType.Quote); model.SelectQuoteType(0); model.Settings.QuoteType.Should().Be(SqlQuoteType.None); }
public async Task SelectCodePlacement() { var settings = new SqlSProcPublishSettings(_storage); var model = await SqlPublishOptionsDialogViewModel.CreateAsync(settings, _coreShell, _pss, _pcsp); model.SelectCodePlacement(1); model.Settings.CodePlacement.Should().Be(RCodePlacement.Table); model.GenerateTable.Should().BeTrue(); model.SelectCodePlacement(0); model.Settings.CodePlacement.Should().Be(RCodePlacement.Inline); model.GenerateTable.Should().BeFalse(); }
/// <summary> /// Generates SQL scripts for the deployment of R code into SQL database. /// Writes scripts to files and pushes files into the target database project. /// </summary> public void Generate(SqlSProcPublishSettings settings, IEnumerable<string> sprocFiles, EnvDTE.Project targetProject) { var targetFolder = Path.Combine(Path.GetDirectoryName(targetProject.FullName), "R\\"); if (!_fs.DirectoryExists(targetFolder)) { _fs.CreateDirectory(targetFolder); } var targetProjectItem = targetProject.ProjectItems.Item("R") ?? targetProject.ProjectItems.AddFolder("R"); var sprocMap = CreateStoredProcedureFiles(settings, sprocFiles, targetFolder, targetProjectItem); if (settings.CodePlacement == RCodePlacement.Table) { CreateRCodeTableFile(settings, targetProject, targetFolder, targetProjectItem); CreatePostDeploymentScriptFile(settings, targetProject, targetFolder, targetProjectItem, sprocMap); } }
/// <summary> /// Generates SQL post deployment script that pushes R code into a table /// as well as /// </summary> private void CreatePostDeploymentScriptFile(SqlSProcPublishSettings settings, EnvDTE.Project targetProject, string targetFolder, EnvDTE.ProjectItem targetProjectItem, SProcMap sprocMap) { var postDeploymentScript = Path.Combine(targetFolder, PostDeploymentScriptName); var g = new SProcScriptGenerator(_fs); var script = g.CreatePostDeploymentScript(settings, sprocMap); _fs.WriteAllText(postDeploymentScript, script); var item = targetProjectItem.ProjectItems.AddFromFile(postDeploymentScript); item.Properties.Item("BuildAction").Value = "PostDeploy"; }
private SProcMap CreateStoredProcedureFiles(SqlSProcPublishSettings settings, IEnumerable<string> sprocFiles, string targetFolder, EnvDTE.ProjectItem targetProjectItem) { var g = new SProcScriptGenerator(_fs); var sprocMap = g.CreateStoredProcedureScripts(settings, sprocFiles); foreach (var name in sprocMap) { var template = sprocMap[name]; if (!string.IsNullOrEmpty(template)) { var sprocFile = Path.ChangeExtension(Path.Combine(targetFolder, name), ".sql"); _fs.WriteAllText(sprocFile, template); targetProjectItem.ProjectItems.AddFromFile(sprocFile); } } return sprocMap; }
public void Publish(SqlSProcPublishSettings settings, IEnumerable<string> sprocFiles) { switch (settings.TargetType) { case PublishTargetType.Project: PublishToProject(settings, sprocFiles); break; case PublishTargetType.Database: PublishToDatabase(settings, sprocFiles); break; default: PublishToDacPac(settings, sprocFiles); break; } }
/// <summary> /// Generates SQL post deployment script that pushes R code into a table /// as well as /// </summary> public string CreatePostDeploymentScript(SqlSProcPublishSettings settings, SProcMap sprocMap) { var sb = new StringBuilder(); sb.AppendLine(Invariant($"INSERT INTO {settings.TableName.ToSqlName(settings.QuoteType)}")); int i = 0; foreach (var sprocName in sprocMap) { var content = sprocMap[sprocName]; sb.Append(Invariant($"VALUES ('{sprocName.ToSqlName(settings.QuoteType)}', '{content}')")); if (i < sprocMap.Count - 1) { sb.Append(','); } sb.AppendLine(string.Empty); i++; } return sb.ToString(); }
public void Publish(SqlSProcPublishSettings settings, IEnumerable <string> sprocFiles) { switch (settings.TargetType) { case PublishTargetType.Project: PublishToProject(settings, sprocFiles); break; case PublishTargetType.Database: PublishToDatabase(settings, sprocFiles); break; default: PublishToDacPac(settings, sprocFiles); break; } }
/// <summary> /// Packages stored procedures into a DACPAC and then publishes it to the database. /// </summary> private void PublishToDatabase(SqlSProcPublishSettings settings, IEnumerable <string> sprocFiles) { var dacpacPath = Path.ChangeExtension(Path.GetTempFileName(), DacPacExtension); CreateDacPac(settings, sprocFiles, dacpacPath); using (var package = _dacServices.Load(dacpacPath)) { var dbName = settings.TargetDatabaseConnection.GetValue(ConnectionStringConverter.OdbcDatabaseKey); var connection = settings.TargetDatabaseConnection.OdbcToSqlClient(); package.Deploy(connection, dbName); var message = Environment.NewLine + string.Format(CultureInfo.InvariantCulture, Resources.SqlPublish_PublishDatabaseSuccess, connection) + Environment.NewLine; _outputWindow.WriteAsync(MessageCategory.General, message).DoNotWait(); RtvsTelemetry.Current?.TelemetryService.ReportEvent(TelemetryArea.SQL, SqlTelemetryEvents.SqlDatabasePublish); } }
/// <summary> /// Packages stored procedures into a DACPAC and then publishes it to the database. /// </summary> private void PublishToDatabase(SqlSProcPublishSettings settings, IEnumerable<string> sprocFiles) { var project = _pss.GetSelectedProject<IVsHierarchy>(); var dacpacPath = Path.ChangeExtension(Path.GetTempFileName(), DacPacExtension); CreateDacPac(settings, sprocFiles, dacpacPath); var package = _dacServices.Load(dacpacPath); var dbName = settings.TargetDatabaseConnection.GetValue(ConnectionStringConverter.OdbcDatabaseKey); var connection = settings.TargetDatabaseConnection.OdbcToSqlClient(); package.Deploy(connection, dbName); var message = Environment.NewLine + string.Format(CultureInfo.InvariantCulture, Resources.SqlPublish_PublishDatabaseSuccess, connection) + Environment.NewLine; _outputWindow.WriteAsync(MessageCategory.General, message).DoNotWait(); RtvsTelemetry.Current?.TelemetryService.ReportEvent(TelemetryArea.SQL, SqlTelemetryEvents.SqlDatabasePublish); }
/// <summary> /// Creates code for stored procedures /// </summary> public SProcMap CreateStoredProcedureScripts(SqlSProcPublishSettings settings, IEnumerable<string> sprocFiles) { var sprocMap = new SProcMap(); foreach (var rFilePath in sprocFiles) { var sprocName = _fs.GetSProcNameFromTemplate(rFilePath); if (!string.IsNullOrEmpty(sprocName)) { string template; if (settings.CodePlacement == RCodePlacement.Inline) { template = FillSprocInlineTemplate(rFilePath, sprocName); } else { template = FillSprocTableTemplate(rFilePath, sprocName, settings.TableName, settings.QuoteType); } if (!string.IsNullOrEmpty(template)) { sprocMap[sprocName] = template; } } } return sprocMap; }
private SProcMap CreateStoredProcedureFiles(SqlSProcPublishSettings settings, IEnumerable <string> sprocFiles, string targetFolder, EnvDTE.ProjectItem targetProjectItem) { var g = new SProcScriptGenerator(_fs); var sprocMap = g.CreateStoredProcedureScripts(settings, sprocFiles); foreach (var name in sprocMap) { var template = sprocMap[name]; if (!string.IsNullOrEmpty(template)) { var sprocFile = Path.ChangeExtension(Path.Combine(targetFolder, name), ".sql"); _fs.WriteAllText(sprocFile, template); targetProjectItem.ProjectItems.AddFromFile(sprocFile); } } return(sprocMap); }
/// <summary> /// Generates SQL scripts for the deployment of R code into SQL database. /// Writes scripts to files and pushes files into the target database project. /// </summary> public void Generate(SqlSProcPublishSettings settings, IEnumerable <string> sprocFiles, EnvDTE.Project targetProject) { var targetFolder = Path.Combine(Path.GetDirectoryName(targetProject.FullName), "R\\"); if (!_fs.DirectoryExists(targetFolder)) { _fs.CreateDirectory(targetFolder); } var targetProjectItem = targetProject.ProjectItems.Item("R") ?? targetProject.ProjectItems.AddFolder("R"); var sprocMap = CreateStoredProcedureFiles(settings, sprocFiles, targetFolder, targetProjectItem); if (settings.CodePlacement == RCodePlacement.Table) { CreateRCodeTableFile(settings, targetProject, targetFolder, targetProjectItem); CreatePostDeploymentScriptFile(settings, targetProject, targetFolder, targetProjectItem, sprocMap); } }
public void Generate(string rFile, RCodePlacement codePlacement, SqlQuoteType quoteType, string sprocName) { var fs = new FileSystem(); var settings = new SqlSProcPublishSettings(); var g = new SProcProjectFilesGenerator(_pss, fs); var targetProjItem = Substitute.For<EnvDTE.ProjectItem>(); var targetProjItems = Substitute.For<EnvDTE.ProjectItems>(); targetProjItem.ProjectItems.Returns(targetProjItems); var rootProjItems = Substitute.For<EnvDTE.ProjectItems>(); rootProjItems.Item("R").Returns((EnvDTE.ProjectItem)null); rootProjItems.AddFolder("R").Returns(targetProjItem); _project.ProjectItems.Returns(rootProjItems); var templateFile = Path.Combine(_files.DestinationPath, Path.GetFileNameWithoutExtension(rFile) + SProcFileExtensions.SProcFileExtension); var sprocFiles = new string[] { Path.Combine(_files.DestinationPath, rFile), Path.Combine(_files.DestinationPath, Path.GetFileNameWithoutExtension(rFile) + SProcFileExtensions.QueryFileExtension), templateFile }; settings.CodePlacement = codePlacement; settings.QuoteType = quoteType; g.Generate(settings, sprocFiles, _project); rootProjItems.Received().AddFolder("R"); var targetFolder = Path.Combine(_files.DestinationPath, "R\\"); var rFilePath = Path.Combine(targetFolder, rFile); var sprocFile = Path.ChangeExtension(Path.Combine(targetFolder, sprocName), ".sql"); targetProjItem.ProjectItems.Received().AddFromFile(sprocFile); if (codePlacement == RCodePlacement.Table) { targetProjItem.ProjectItems.Received().AddFromFile(Path.Combine(targetFolder, SProcProjectFilesGenerator.PostDeploymentScriptName)); targetProjItem.ProjectItems.Received().AddFromFile(Path.Combine(targetFolder, SProcProjectFilesGenerator.CreateRCodeTableScriptName)); } var mode = codePlacement == RCodePlacement.Inline ? "inline" : "table"; var baseline = fs.ReadAllText(Path.Combine(_files.DestinationPath, Invariant($"{Path.GetFileNameWithoutExtension(rFile)}.{mode}.baseline.sql"))); string actual = fs.ReadAllText(sprocFile); BaselineCompare.CompareStringLines(baseline, actual); }
private void Handle() { var project = _pss.GetSelectedProject<IVsHierarchy>()?.GetDTEProject(); if (project != null) { var sprocFiles = project.GetSProcFiles(_pss); if (sprocFiles.Any()) { try { // Make sure all files are saved and up to date on disk. var dte = _appShell.GetGlobalService<DTE>(typeof(DTE)); dte.ExecuteCommand("File.SaveAll"); var publisher = new SProcPublisher(_appShell, _pss, _fs, _dacServicesProvider.GetDacPackageServices()); var settings = new SqlSProcPublishSettings(_settings); publisher.Publish(settings, sprocFiles); } catch (Exception ex) { _appShell.ShowErrorMessage(string.Format(CultureInfo.InvariantCulture, Resources.SqlPublish_PublishError, ex.Message)); } } else { _appShell.ShowErrorMessage(Resources.SqlPublishDialog_NoSProcFiles); } } }
/// <summary> /// Generates SQL post deployment script that pushes R code into a table /// as well as /// </summary> public string CreatePostDeploymentScript(SqlSProcPublishSettings settings, SProcMap sprocMap) { var sb = new StringBuilder(); sb.AppendLine(Invariant($"INSERT INTO {settings.TableName.ToSqlName(settings.QuoteType)}")); int i = 0; foreach (var sprocName in sprocMap) { var content = sprocMap[sprocName]; sb.Append(Invariant($"VALUES ('{sprocName.ToSqlName(settings.QuoteType)}', '{content}')")); if (i < sprocMap.Count - 1) { sb.Append(','); } sb.AppendLine(string.Empty); i++; } return(sb.ToString()); }
public async Task Constructor() { var settings = new SqlSProcPublishSettings(_storage); var model = await SqlPublishOptionsDialogViewModel.CreateAsync(settings, _coreShell, _pss, _pcsp); model.TargetTypeNames.Should().HaveCount(3); model.SelectedTargetTypeIndex.Should().Be(0); model.QuoteTypeNames.Should().HaveCount(3); model.SelectedQuoteTypeIndex.Should().Be(0); model.CodePlacementNames.Should().HaveCount(2); model.SelectedCodePlacementIndex.Should().Be(0); model.Targets.Should().BeEmpty(); model.TargetHasName.Should().BeFalse(); model.GenerateTable.Should().BeFalse(); model.Settings.Should().NotBeNull(); model.Settings.CodePlacement.Should().Be(RCodePlacement.Inline); model.Settings.QuoteType.Should().Be(SqlQuoteType.None); model.Settings.TargetType.Should().Be(PublishTargetType.Dacpac); }
public async Task NoDbProjectList() { _storage.GetSetting(SqlSProcPublishSettings.TargetTypeSettingName, PublishTargetType.Dacpac).Returns(PublishTargetType.Project); var settings = new SqlSProcPublishSettings(_storage); var model = await SqlPublishOptionsDialogViewModel.CreateAsync(settings, _coreShell, _pss, _pcsp); model.Settings.TargetType.Should().Be(PublishTargetType.Project); model.Targets.Should().HaveCount(1); model.Targets[0].Should().Be(Resources.SqlPublishDialog_NoDatabaseProjects); }
/// <summary> /// Packages stored procedures into a DACPAC. /// </summary> private void PublishToDacPac(SqlSProcPublishSettings settings, IEnumerable<string> sprocFiles) { var project = _pss.GetSelectedProject<IVsHierarchy>()?.GetDTEProject(); var dacpacPath = Path.ChangeExtension(project.FullName, DacPacExtension); CreateDacPac(settings, sprocFiles, dacpacPath); RtvsTelemetry.Current?.TelemetryService.ReportEvent(TelemetryArea.SQL, SqlTelemetryEvents.SqlDacPacPublish); }
public void GenerateEmpty() { var fs = new FileSystem(); var g = new SProcProjectFilesGenerator(_pss, fs); var settings = new SqlSProcPublishSettings(); g.Generate(settings, Enumerable.Empty<string>(), _project); }
/// <summary> /// Generates SQL files for stored procedures as well as publishing scripts /// and then adds them to the target database project. /// </summary> private void PublishToProject(SqlSProcPublishSettings settings, IEnumerable<string> sprocFiles) { Check.ArgumentNull(nameof(settings), settings.TargetProject); var targetProject = _pss.GetProject(settings.TargetProject); var generator = new SProcProjectFilesGenerator(_pss, _fs); generator.Generate(settings, sprocFiles, targetProject); RtvsTelemetry.Current?.TelemetryService.ReportEvent(TelemetryArea.SQL, SqlTelemetryEvents.SqlProjectPublish); }
public static async Task<SqlPublishOptionsDialogViewModel> CreateAsync( SqlSProcPublishSettings settings, ICoreShell coreShell, IProjectSystemServices pss, IProjectConfigurationSettingsProvider pcsp) { var model = new SqlPublishOptionsDialogViewModel(settings, coreShell, pss, pcsp); await model.InitializeAsync(); return model; }
public async Task NoDbConnections() { ConfigureSettingAccessMock(Enumerable.Empty<IConfigurationSetting>()); _storage.GetSetting(SqlSProcPublishSettings.TargetTypeSettingName, PublishTargetType.Dacpac).Returns(PublishTargetType.Database); var settings = new SqlSProcPublishSettings(_storage); var model = await SqlPublishOptionsDialogViewModel.CreateAsync(settings, _coreShell, _pss, _pcsp); model.Settings.TargetType.Should().Be(PublishTargetType.Database); model.Targets.Should().HaveCount(1); model.Targets[0].Should().Be(Resources.SqlPublishDialog_NoDatabaseConnections); }
public async Task DbConnectionsList() { var s1 = Substitute.For<IConfigurationSetting>(); s1.Name.Returns("dbConn1"); s1.Value.Returns("dbConn1_String"); s1.EditorType.Returns(ConnectionStringEditor.ConnectionStringEditorName); var s2 = Substitute.For<IConfigurationSetting>(); s2.Name.Returns("dbConn2"); s2.Value.Returns("dbConn2_String"); s2.EditorType.Returns(ConnectionStringEditor.ConnectionStringEditorName); var s3 = Substitute.For<IConfigurationSetting>(); s3.Name.Returns("dbConn3"); s3.Value.Returns("dbConn3_String"); s3.EditorType.Returns(ConnectionStringEditor.ConnectionStringEditorName); var s4 = Substitute.For<IConfigurationSetting>(); s4.Name.Returns("dbConn4"); s4.Value.Returns("dbConn4_String"); ConfigureSettingAccessMock(new IConfigurationSetting[] { s1, s4, s2, s3 }); _storage.GetSetting(SqlSProcPublishSettings.TargetTypeSettingName, PublishTargetType.Dacpac).Returns(PublishTargetType.Database); _storage.GetSetting(SqlSProcPublishSettings.TargetDatabaseConnectionSettingName, Arg.Any<string>()).Returns(("dbConn2_String")); var settings = new SqlSProcPublishSettings(_storage); var model = await SqlPublishOptionsDialogViewModel.CreateAsync(settings, _coreShell, _pss, _pcsp); model.Settings.TargetType.Should().Be(PublishTargetType.Database); model.Settings.TargetDatabaseConnection.Should().Be("dbConn2_String"); model.Targets.Should().HaveCount(3); model.Targets[0].Should().Be("dbConn1"); model.Targets[1].Should().Be("dbConn2"); model.Targets[2].Should().Be("dbConn3"); model.SelectedTargetIndex.Should().Be(1); }
private SqlPublishOptionsDialogViewModel(SqlSProcPublishSettings settings, ICoreShell coreShell, IProjectSystemServices pss, IProjectConfigurationSettingsProvider pcsp) { _coreShell = coreShell; _pss = pss; _pcsp = pcsp; Settings = settings; }
public string CreateRCodeTableScript(SqlSProcPublishSettings settings) => Invariant( $@"CREATE TABLE {settings.TableName.ToSqlName(settings.QuoteType)} ( {SProcColumnName} NVARCHAR(64), {RCodeColumnName} NVARCHAR(max) )");
public async Task SelectTargetType() { var settings = new SqlSProcPublishSettings(_storage); var model = await SqlPublishOptionsDialogViewModel.CreateAsync(settings, _coreShell, _pss, _pcsp); await model.SelectTargetTypeAsync(1); model.Settings.TargetType.Should().Be(PublishTargetType.Database); model.TargetHasName.Should().BeTrue(); await model.SelectTargetTypeAsync(2); model.Settings.TargetType.Should().Be(PublishTargetType.Project); model.TargetHasName.Should().BeTrue(); await model.SelectTargetTypeAsync(0); model.Settings.TargetType.Should().Be(PublishTargetType.Dacpac); model.TargetHasName.Should().BeFalse(); }
public string CreateRCodeTableScript(SqlSProcPublishSettings settings) => Invariant( $@"CREATE TABLE {settings.TableName.ToSqlName(settings.QuoteType)} ( {SProcColumnName} NVARCHAR(64), {RCodeColumnName} NVARCHAR(max) )");
private void CreateDacPac(SqlSProcPublishSettings settings, IEnumerable<string> sprocFiles, string dacpacPath) { var project = _pss.GetSelectedProject<IVsHierarchy>()?.GetDTEProject(); if (project != null) { var g = new SProcScriptGenerator(_fs); var sprocMap = g.CreateStoredProcedureScripts(settings, sprocFiles); var builder = _dacServices.GetBuilder(); builder.Build(dacpacPath, project.Name, sprocMap.Scripts); } }
private async Task InitializeModelAsync() { var settings = new SqlSProcPublishSettings(_settings); _model = await SqlPublishOptionsDialogViewModel.CreateAsync(settings, _appShell, _pss, _pcsp); DataContext = _model; }
public async Task ProjectList() { var projects = Substitute.For<EnvDTE.Projects>(); var p1 = Substitute.For<EnvDTE.Project>(); p1.FileName.Returns("project1.sqlproj"); p1.Name.Returns("project1"); var p2 = Substitute.For<EnvDTE.Project>(); p2.FileName.Returns("project2.sqlproj"); p2.Name.Returns("project2"); var p3 = Substitute.For<EnvDTE.Project>(); p3.FileName.Returns("project3.csproj"); p3.Name.Returns("project3"); projects.GetEnumerator().Returns((new EnvDTE.Project[] { p1, p2, p3 }).GetEnumerator()); var sol = Substitute.For<EnvDTE.Solution>(); sol.Projects.Returns(projects); _pss.GetSolution().Returns(sol); _storage.GetSetting(SqlSProcPublishSettings.TargetTypeSettingName, PublishTargetType.Dacpac).Returns(PublishTargetType.Project); _storage.GetSetting(SqlSProcPublishSettings.TargetProjectSettingName, Arg.Any<string>()).Returns(("project2")); var settings = new SqlSProcPublishSettings(_storage); var model = await SqlPublishOptionsDialogViewModel.CreateAsync(settings, _coreShell, _pss, _pcsp); model.Settings.TargetType.Should().Be(PublishTargetType.Project); model.Settings.TargetProject.Should().Be("project2"); model.Targets.Should().HaveCount(2); model.Targets[0].Should().Be("project1"); model.Targets[1].Should().Be("project2"); model.SelectedTargetIndex.Should().Be(1); }