/// <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);
}
