public void UpdateRaml(string ramlFilePath)
{
var dte = ServiceProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
var contractsFolderPath = Path.GetDirectoryName(proj.FullName) + Path.DirectorySeparatorChar + ContractsFolderName + Path.DirectorySeparatorChar;
var refFilePath = InstallerServices.GetRefFilePath(ramlFilePath);
var includesFolderPath = contractsFolderPath + Path.DirectorySeparatorChar + InstallerServices.IncludesFolderName;
var ramlSource = RamlReferenceReader.GetRamlSource(refFilePath);
if (string.IsNullOrWhiteSpace(ramlSource))
{
ramlSource = ramlFilePath;
}
var includesManager = new RamlIncludesManager();
var result = includesManager.Manage(ramlSource, includesFolderPath, contractsFolderPath + Path.DirectorySeparatorChar);
if (result.IsSuccess)
{
File.WriteAllText(ramlFilePath, result.ModifiedContents);
var parameters = new RamlChooserActionParams(ramlFilePath, ramlFilePath, null, null,
Path.GetFileName(ramlFilePath).ToLowerInvariant(),
RamlReferenceReader.GetRamlNamespace(refFilePath), null)
{
UseAsyncMethods = RamlReferenceReader.GetRamlUseAsyncMethods(refFilePath),
IncludeApiVersionInRoutePrefix = RamlReferenceReader.GetRamlIncludeApiVersionInRoutePrefix(refFilePath),
ModelsFolder = RamlReferenceReader.GetModelsFolder(refFilePath),
ImplementationControllersFolder = RamlReferenceReader.GetImplementationControllersFolder(refFilePath),
AddGeneratedSuffixToFiles = RamlReferenceReader.GetAddGeneratedSuffix(refFilePath)
};
Scaffold(ramlFilePath, parameters);
}
}
private void AddOrUpdateUnitTestsControllerBase(RamlChooserActionParams parameters, string unitTestFolderPath,
WebApiGeneratorModel model, ProjectItem folderItem, string extensionPath)
{
templatesManager.CopyServerTemplateToProjectFolder(unitTestFolderPath, UnitTestsControllerTemplateName,
RAML.Tools.Properties.Settings.Default.BaseControllerTestsTemplateTitle, TemplateSubFolder);
var templatesFolder = Path.Combine(unitTestFolderPath, "Templates");
var targetFolderPath = GetTargetFolderPath(unitTestFolderPath, Path.GetFileName(parameters.RamlFilePath));
var controllerBaseTemplateParams =
new TemplateParams <ControllerObject>(Path.Combine(templatesFolder, UnitTestsControllerTemplateName),
folderItem, "controllerObject", model.Controllers, targetFolderPath, folderItem, extensionPath,
parameters.ControllersNamespace, "ControllerTests", true,
GetVersionPrefix(parameters.IncludeApiVersionInRoutePrefix, model.ApiVersion))
{
Title = RAML.Tools.Properties.Settings.Default.BaseControllerTestsTemplateTitle,
IncludeHasModels = true,
HasModels = model.Objects.Any(o => o.IsScalar == false) || model.Enums.Any(),
UseAsyncMethods = parameters.UseAsyncMethods,
IncludeApiVersionInRoutePrefix = parameters.IncludeApiVersionInRoutePrefix,
ApiVersion = model.ApiVersion,
TargetFolder = targetFolderPath,
TestsNamespace = parameters.TestsNamespace,
ModelsNamespace = parameters.ModelsNamespace
};
codeGenerator.GenerateCodeFromTemplate(controllerBaseTemplateParams);
}
private void AddOrUpdateModels(RamlChooserActionParams parameters, string contractsFolderPath, ProjectItem ramlItem, WebApiGeneratorModel model, ProjectItem contractsFolderItem, string extensionPath)
{
templatesManager.CopyServerTemplateToProjectFolder(contractsFolderPath, ModelTemplateName,
Settings.Default.ModelsTemplateTitle, TemplateSubFolder);
var templatesFolder = Path.Combine(contractsFolderPath, "Templates");
var models = model.Objects;
// when is an XML model, skip empty objects
if (model.Objects.Any(o => !string.IsNullOrWhiteSpace(o.GeneratedCode)))
{
models = model.Objects.Where(o => o.Properties.Any() || !string.IsNullOrWhiteSpace(o.GeneratedCode));
}
models = models.Where(o => !o.IsArray || o.Type == null); // skip array of primitives
models = models.Where(o => !o.IsScalar); // skip scalar types
var targetFolderPath = GetTargetFolderPath(contractsFolderPath, ramlItem.FileNames[0]);
var apiObjectTemplateParams = new TemplateParams <ApiObject>(
Path.Combine(templatesFolder, ModelTemplateName), ramlItem, "apiObject", models,
contractsFolderPath, contractsFolderItem, extensionPath, parameters.TargetNamespace,
GetVersionPrefix(parameters.IncludeApiVersionInRoutePrefix, model.ApiVersion) +
(parameters.AddGeneratedSuffixToFiles ? ".generated" : string.Empty))
{
Title = Settings.Default.ModelsTemplateTitle,
RelativeFolder = parameters.ModelsFolder,
TargetFolder = TargetFolderResolver.GetModelsTargetFolder(ramlItem.ContainingProject,
targetFolderPath, parameters.ModelsFolder)
};
codeGenerator.GenerateCodeFromTemplate(apiObjectTemplateParams);
}
public override void AddRamlReference(RamlChooserActionParams parameters)
{
try
{
Logger.LogInformation("Add RAML Reference process started");
var dte = ServiceProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
AddPortableImports(proj);
InstallNugetDependencies(proj);
Logger.LogInformation("Nuget Dependencies installed");
AddFilesToProject(parameters.RamlFilePath, proj, parameters.TargetNamespace, parameters.RamlSource, parameters.TargetFileName, parameters.ClientRootClassName);
Logger.LogInformation("Files added to project");
}
catch (Exception ex)
{
Logger.LogError(ex);
var errorMessage = "Error when trying to add the RAML reference. " + ex.Message;
if (ex.InnerException != null)
{
errorMessage += " - " + ex.InnerException;
}
MessageBox.Show(errorMessage);
throw;
}
}
public void ScaffoldToProject(RamlChooserActionParams parameters, Project proj)
{
Microsoft.VisualStudio.Shell.ThreadHelper.ThrowIfNotOnUIThread();
var data = parameters.Data;
if (data == null || data.RamlDocument == null)
{
return;
}
var model = new WebApiGeneratorService(data.RamlDocument, parameters.ControllersNamespace, parameters.ModelsNamespace).BuildModel();
var unitTestsFolderItem = VisualStudioAutomationHelper.AddFolderIfNotExists(proj, UnitTestsFolderName);
var unitTestsFolderPath = Path.GetDirectoryName(proj.FullName) + Path.DirectorySeparatorChar +
UnitTestsFolderName + Path.DirectorySeparatorChar;
var templates = new[]
{
UnitTestsControllerTemplateName,
UnitTestsControllerImplementationTemplateName,
ModelTemplateName,
EnumTemplateName
};
if (!templatesManager.ConfirmWhenIncompatibleServerTemplate(unitTestsFolderPath, templates))
{
return;
}
var extensionPath = Path.GetDirectoryName(GetType().Assembly.Location) + Path.DirectorySeparatorChar;
AddOrUpdateUnitTestsControllerBase(parameters, unitTestsFolderPath, model, unitTestsFolderItem, extensionPath);
AddOrUpdateUnitTestsControllerImplementations(parameters, unitTestsFolderPath, proj, model, unitTestsFolderItem, extensionPath);
}
public void AddContract(RamlChooserActionParams parameters)
{
var dte = serviceProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
InstallNugetDependencies(proj);
if (VisualStudioAutomationHelper.IsAVisualStudio2015Project(proj))
{
AddXmlFormatterInWebApiConfig(proj);
}
var folderItem = VisualStudioAutomationHelper.AddFolderIfNotExists(proj, contractsFolderName);
var contractsFolderPath = Path.GetDirectoryName(proj.FullName) + Path.DirectorySeparatorChar + contractsFolderName + Path.DirectorySeparatorChar;
var targetFolderPath = GetTargetFolderPath(contractsFolderPath, parameters.TargetFileName, proj);
if (!Directory.Exists(targetFolderPath))
{
Directory.CreateDirectory(targetFolderPath);
}
if (string.IsNullOrWhiteSpace(parameters.RamlSource) && !string.IsNullOrWhiteSpace(parameters.RamlTitle))
{
AddEmptyContract(folderItem, contractsFolderPath, parameters);
}
else
{
AddContractFromFile(folderItem, contractsFolderPath, parameters);
}
}
public override void AddContract(RamlChooserActionParams parameters)
{
var dte = ServiceProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
InstallNugetDependencies(proj, newtonsoftJsonForCorePackageVersion);
var folderItem = VisualStudioAutomationHelper.AddFolderIfNotExists(proj, ContractsFolderName);
var contractsFolderPath = Path.GetDirectoryName(proj.FullName) + Path.DirectorySeparatorChar + ContractsFolderName + Path.DirectorySeparatorChar;
var targetFolderPath = GetTargetFolderPath(contractsFolderPath, parameters.TargetFileName);
if (!Directory.Exists(targetFolderPath))
{
Directory.CreateDirectory(targetFolderPath);
}
if (string.IsNullOrWhiteSpace(parameters.RamlSource) && !string.IsNullOrWhiteSpace(parameters.RamlTitle))
{
AddEmptyContract(folderItem, contractsFolderPath, parameters);
}
else
{
AddContractFromFile(folderItem, contractsFolderPath, parameters);
}
}
public override void AddContract(RamlChooserActionParams parameters)
{
Microsoft.VisualStudio.Shell.ThreadHelper.ThrowIfNotOnUIThread();
Tracking.Track("Asp.Net WebApi Scaffold");
var dte = ServiceProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
InstallDependencies(proj, newtonsoftJsonPackageVersion);
AddXmlFormatterInWebApiConfig(proj);
var folderItem = VisualStudioAutomationHelper.AddFolderIfNotExists(proj, ContractsFolderName);
var contractsFolderPath = Path.GetDirectoryName(proj.FullName) + Path.DirectorySeparatorChar + ContractsFolderName + Path.DirectorySeparatorChar;
var targetFolderPath = GetTargetFolderPath(contractsFolderPath, parameters.TargetFileName);
if (!Directory.Exists(targetFolderPath))
{
Directory.CreateDirectory(targetFolderPath);
}
if (string.IsNullOrWhiteSpace(parameters.RamlSource) && !string.IsNullOrWhiteSpace(parameters.RamlTitle))
{
AddEmptyContract(folderItem, contractsFolderPath, parameters);
}
else
{
AddContractFromFile(folderItem, contractsFolderPath, parameters);
}
}
private void AddOrUpdateControllerImplementations(RamlChooserActionParams parameters, string contractsFolderPath, Project proj,
WebApiGeneratorModel model, ProjectItem folderItem, string extensionPath)
{
templatesManager.CopyServerTemplateToProjectFolder(contractsFolderPath, ControllerImplementationTemplateName,
Settings.Default.ControllerImplementationTemplateTitle, TemplateSubFolder);
var controllersFolderItem = VisualStudioAutomationHelper.AddFolderIfNotExists(proj, "Controllers");
var templatesFolder = Path.Combine(contractsFolderPath, "Templates");
var controllerImplementationTemplateParams =
new TemplateParams <ControllerObject>(
Path.Combine(templatesFolder, ControllerImplementationTemplateName),
controllersFolderItem, "controllerObject", model.Controllers, contractsFolderPath, folderItem,
extensionPath, parameters.TargetNamespace, "Controller", false,
GetVersionPrefix(parameters.IncludeApiVersionInRoutePrefix, model.ApiVersion))
{
TargetFolder = TargetFolderResolver.GetImplementationControllersFolderPath(proj, parameters.ImplementationControllersFolder),
RelativeFolder = parameters.ImplementationControllersFolder,
Title = Settings.Default.ControllerImplementationTemplateTitle,
IncludeHasModels = true,
HasModels = model.Objects.Any(o => o.IsScalar == false) || model.Enums.Any(),
UseAsyncMethods = parameters.UseAsyncMethods,
IncludeApiVersionInRoutePrefix = parameters.IncludeApiVersionInRoutePrefix,
ApiVersion = model.ApiVersion
};
codeGenerator.GenerateCodeFromTemplate(controllerImplementationTemplateParams);
}
private void AddOrUpdateControllerBase(RamlChooserActionParams parameters, string contractsFolderPath, ProjectItem ramlItem,
WebApiGeneratorModel model, ProjectItem folderItem, string extensionPath)
{
templatesManager.CopyServerTemplateToProjectFolder(contractsFolderPath, ControllerBaseTemplateName,
Settings.Default.BaseControllerTemplateTitle, TemplateSubFolder);
var templatesFolder = Path.Combine(contractsFolderPath, "Templates");
var targetFolderPath = GetTargetFolderPath(contractsFolderPath, ramlItem.FileNames[0]);
var controllerBaseTemplateParams =
new TemplateParams <ControllerObject>(Path.Combine(templatesFolder, ControllerBaseTemplateName),
ramlItem, "controllerObject", model.Controllers, targetFolderPath, folderItem, extensionPath,
parameters.TargetNamespace, "Controller", true,
GetVersionPrefix(parameters.IncludeApiVersionInRoutePrefix, model.ApiVersion))
{
Title = Settings.Default.BaseControllerTemplateTitle,
IncludeHasModels = true,
HasModels = model.Objects.Any(o => o.IsScalar == false) || model.Enums.Any(),
UseAsyncMethods = parameters.UseAsyncMethods,
IncludeApiVersionInRoutePrefix = parameters.IncludeApiVersionInRoutePrefix,
ApiVersion = model.ApiVersion,
TargetFolder = targetFolderPath
};
codeGenerator.GenerateCodeFromTemplate(controllerBaseTemplateParams);
}
public void Scaffold(string ramlSource, RamlChooserActionParams parameters)
{
Microsoft.VisualStudio.Shell.ThreadHelper.ThrowIfNotOnUIThread();
var dte = ServiceProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
ScaffoldToProject(parameters, proj);
}
public void Scaffold(string ramlSource, RamlChooserActionParams parameters)
{
var data = RamlScaffolderHelper.GetRamlData(ramlSource, parameters.TargetNamespace);
if (data == null || data.Model == null)
{
return;
}
var model = data.Model;
var dte = serviceProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
var contractsFolderItem = VisualStudioAutomationHelper.AddFolderIfNotExists(proj, contractsFolderName);
var ramlItem =
contractsFolderItem.ProjectItems.Cast <ProjectItem>()
.First(i => i.Name.ToLowerInvariant() == parameters.TargetFileName.ToLowerInvariant());
var contractsFolderPath = Path.GetDirectoryName(proj.FullName) + Path.DirectorySeparatorChar +
contractsFolderName + Path.DirectorySeparatorChar;
if (VisualStudioAutomationHelper.IsAVisualStudio2015Project(proj))
{
templateSubFolder = "AspNet5";
}
else
{
templateSubFolder = "RAMLWebApi2Scaffolder";
}
var templates = new[]
{
ControllerBaseTemplateName,
ControllerInterfaceTemplateName,
ControllerImplementationTemplateName,
ModelTemplateName,
EnumTemplateName
};
if (!templatesManager.ConfirmWhenIncompatibleServerTemplate(contractsFolderPath, templates))
{
return;
}
var extensionPath = Path.GetDirectoryName(GetType().Assembly.Location) + Path.DirectorySeparatorChar;
AddOrUpdateModels(parameters, contractsFolderPath, ramlItem, model, contractsFolderItem, extensionPath);
AddOrUpdateEnums(parameters, contractsFolderPath, ramlItem, model, contractsFolderItem, extensionPath);
AddOrUpdateControllerBase(parameters, contractsFolderPath, ramlItem, model, contractsFolderItem, extensionPath);
AddOrUpdateControllerInterfaces(parameters, contractsFolderPath, ramlItem, model, contractsFolderItem, extensionPath);
AddOrUpdateControllerImplementations(parameters, contractsFolderPath, proj, model, contractsFolderItem, extensionPath);
}
private RamlProperties Map(RamlChooserActionParams parameters)
{
return(new RamlProperties
{
IncludeApiVersionInRoutePrefix = parameters.IncludeApiVersionInRoutePrefix,
UseAsyncMethods = parameters.UseAsyncMethods,
Namespace = parameters.TargetNamespace,
Source = parameters.RamlSource,
ClientName = parameters.ClientRootClassName,
ModelsFolder = parameters.ModelsFolder,
ImplementationControllersFolder = parameters.ImplementationControllersFolder,
AddGeneratedSuffix = parameters.AddGeneratedSuffixToFiles
});
}
public void AddContract(RamlChooserActionParams parameters)
{
var dte = serviceProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
var folderItem = VisualStudioAutomationHelper.AddFolderIfNotExists(proj, folderName);
var generatedFolderPath = Path.GetDirectoryName(proj.FullName) + Path.DirectorySeparatorChar + folderName + Path.DirectorySeparatorChar;
if (string.IsNullOrWhiteSpace(parameters.RamlSource) && !string.IsNullOrWhiteSpace(parameters.RamlTitle))
{
AddEmptyContract(parameters.TargetFileName, parameters.RamlTitle, folderItem, generatedFolderPath, parameters.TargetNamespace, parameters.TargetFileName);
}
else
{
AddContractFromFile(parameters.RamlFilePath, parameters.TargetNamespace, parameters.RamlSource,
parameters.DoNotScaffold, folderItem, generatedFolderPath, parameters.TargetFileName);
}
}
private void AddOrUpdateModels(RamlChooserActionParams parameters, string contractsFolderPath, ProjectItem ramlItem, WebApiGeneratorModel model, ProjectItem contractsFolderItem, string extensionPath)
{
ThreadHelper.ThrowIfNotOnUIThread();
templatesManager.CopyServerTemplateToProjectFolder(contractsFolderPath, ModelTemplateName,
RAML.Tools.Properties.Settings.Default.ModelsTemplateTitle, TemplateSubFolder);
var templatesFolder = Path.Combine(contractsFolderPath, "Templates");
var models = model.Objects;
// when is an XML model, skip empty objects
if (model.Objects.Any(o => !string.IsNullOrWhiteSpace(o.GeneratedCode)))
{
models = model.Objects.Where(o => o.Properties.Any() || !string.IsNullOrWhiteSpace(o.GeneratedCode));
}
// when array has no properties, set it collection on base type
foreach (var arrayModel in models.Where(o => o.IsArray && o.Properties.Count == 0 && o.Type != null &&
CollectionTypeHelper.IsCollection(o.Type) && !NewNetTypeMapper.IsPrimitiveType(CollectionTypeHelper.GetBaseType(o.Type))))
{
arrayModel.BaseClass = arrayModel.Type.Substring(1); // remove the initil "I" to make it a concrete class
}
// skip array of primitives
models = models.Where(o => o.Type == null || !(CollectionTypeHelper.IsCollection(o.Type) &&
NewNetTypeMapper.IsPrimitiveType(CollectionTypeHelper.GetBaseType(o.Type))));
models = models.Where(o => !o.IsScalar); // skip scalar types
var targetFolderPath = GetTargetFolderPath(contractsFolderPath, ramlItem.FileNames[0]);
var apiObjectTemplateParams = new TemplateParams <ApiObject>(
Path.Combine(templatesFolder, ModelTemplateName), ramlItem, "apiObject", models,
contractsFolderPath, contractsFolderItem, extensionPath, parameters.ControllersNamespace,
GetVersionPrefix(parameters.IncludeApiVersionInRoutePrefix, model.ApiVersion) +
(parameters.AddGeneratedSuffixToFiles ? ".generated" : string.Empty))
{
Title = RAML.Tools.Properties.Settings.Default.ModelsTemplateTitle,
RelativeFolder = parameters.ModelsFolder,
TargetFolder = TargetFolderResolver.GetModelsTargetFolder(ramlItem.ContainingProject,
targetFolderPath, parameters.ModelsFolder),
ModelsNamespace = parameters.ModelsNamespace
};
codeGenerator.GenerateCodeFromTemplate(apiObjectTemplateParams);
}
private static void ScaffoldMainRamlFiles(IEnumerable <string> ramlFiles)
{
var service = GetRamlScaffoldService(Microsoft.VisualStudio.Shell.ServiceProvider.GlobalProvider);
foreach (var ramlFile in ramlFiles)
{
var refFilePath = InstallerServices.GetRefFilePath(ramlFile);
var includeApiVersionInRoutePrefix = RamlReferenceReader.GetRamlIncludeApiVersionInRoutePrefix(refFilePath);
var parameters = new RamlChooserActionParams(ramlFile, ramlFile, null, null, Path.GetFileName(ramlFile),
RamlReferenceReader.GetRamlNamespace(refFilePath), null)
{
UseAsyncMethods = RamlReferenceReader.GetRamlUseAsyncMethods(refFilePath),
IncludeApiVersionInRoutePrefix = includeApiVersionInRoutePrefix,
ModelsFolder = RamlReferenceReader.GetModelsFolder(refFilePath),
ImplementationControllersFolder = RamlReferenceReader.GetImplementationControllersFolder(refFilePath),
AddGeneratedSuffixToFiles = RamlReferenceReader.GetAddGeneratedSuffix(refFilePath)
};
service.Scaffold(ramlFile, parameters);
}
}
public override void AddTests(RamlChooserActionParams parameters)
{
Tracking.Track("Unit Tests Scaffold (Asp.Net Core)");
var dte = ServiceProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
InstallDependencies(proj);
var folderItem = VisualStudioAutomationHelper.AddFolderIfNotExists(proj, UnitTestsFolderName);
var contractsFolderPath = Path.GetDirectoryName(proj.FullName) + Path.DirectorySeparatorChar + UnitTestsFolderName + Path.DirectorySeparatorChar;
var targetFolderPath = GetTargetFolderPath(contractsFolderPath, parameters.TargetFileName);
if (!Directory.Exists(targetFolderPath))
{
Directory.CreateDirectory(targetFolderPath);
}
AddUnitTests(folderItem, contractsFolderPath, parameters);
}
private void AddOrUpdateEnums(RamlChooserActionParams parameters, string contractsFolderPath, ProjectItem ramlItem, WebApiGeneratorModel model, ProjectItem folderItem, string extensionPath)
{
templatesManager.CopyServerTemplateToProjectFolder(contractsFolderPath, EnumTemplateName,
Settings.Default.EnumsTemplateTitle, TemplateSubFolder);
var templatesFolder = Path.Combine(contractsFolderPath, "Templates");
var targetFolderPath = GetTargetFolderPath(contractsFolderPath, ramlItem.FileNames[0]);
var apiEnumTemplateParams = new TemplateParams <ApiEnum>(
Path.Combine(templatesFolder, EnumTemplateName), ramlItem, "apiEnum", model.Enums,
targetFolderPath, folderItem, extensionPath, parameters.TargetNamespace,
GetVersionPrefix(parameters.IncludeApiVersionInRoutePrefix, model.ApiVersion))
{
Title = Settings.Default.ModelsTemplateTitle,
RelativeFolder = parameters.ModelsFolder,
TargetFolder = TargetFolderResolver.GetModelsTargetFolder(ramlItem.ContainingProject,
targetFolderPath, parameters.ModelsFolder)
};
codeGenerator.GenerateCodeFromTemplate(apiEnumTemplateParams);
}
private void AddContractFromFile(ProjectItem folderItem, string folderPath, RamlChooserActionParams parameters)
{
var includesFolderPath = folderPath + Path.DirectorySeparatorChar + InstallerServices.IncludesFolderName;
var includesManager = new RamlIncludesManager();
var result = includesManager.Manage(parameters.RamlSource, includesFolderPath, confirmOverrite: true, rootRamlPath: folderPath + Path.DirectorySeparatorChar);
var includesFolderItem = folderItem.ProjectItems.Cast <ProjectItem>().FirstOrDefault(i => i.Name == InstallerServices.IncludesFolderName);
if (includesFolderItem == null && !VisualStudioAutomationHelper.IsAVisualStudio2015Project(folderItem.ContainingProject))
{
includesFolderItem = folderItem.ProjectItems.AddFolder(InstallerServices.IncludesFolderName);
}
foreach (var file in result.IncludedFiles)
{
if (!VisualStudioAutomationHelper.IsAVisualStudio2015Project(folderItem.ContainingProject) || !File.Exists(file))
{
includesFolderItem.ProjectItems.AddFromFile(file);
}
}
//var existingIncludeItems = includesFolderItem.ProjectItems.Cast<ProjectItem>();
//var oldIncludedFiles = existingIncludeItems.Where(item => !result.IncludedFiles.Contains(item.FileNames[0]));
//InstallerServices.RemoveSubItemsAndAssociatedFiles(oldIncludedFiles);
var ramlProjItem = AddOrUpdateRamlFile(result.ModifiedContents, folderItem, folderPath, parameters.TargetFileName);
InstallerServices.RemoveSubItemsAndAssociatedFiles(ramlProjItem);
var targetFolderPath = GetTargetFolderPath(folderPath, parameters.TargetFileName, folderItem.ContainingProject);
RamlProperties props = Map(parameters);
var refFilePath = InstallerServices.AddRefFile(parameters.RamlFilePath, targetFolderPath, parameters.TargetFileName, props);
ramlProjItem.ProjectItems.AddFromFile(refFilePath);
Scaffold(ramlProjItem.FileNames[0], parameters);
}
public void AddRamlReference(RamlChooserActionParams parameters)
{
try
{
ActivityLog.LogInformation(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource, "Add RAML Reference process started");
var dte = serviceProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
InstallNugetDependencies(proj);
ActivityLog.LogInformation(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource, "Nuget Dependencies installed");
AddFilesToProject(parameters.RamlFilePath, proj, parameters.TargetNamespace, parameters.RamlSource, parameters.TargetFileName, parameters.ClientRootClassName);
ActivityLog.LogInformation(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource, "Files added to project");
}
catch (Exception ex)
{
ActivityLog.LogError(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource,
VisualStudioAutomationHelper.GetExceptionInfo(ex));
MessageBox.Show("Error when trying to add the RAML reference. " + ex.Message);
throw;
}
}
public void AddContract(RamlChooserActionParams parameters)
{
var dte = serviceProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
InstallNugetDependencies(proj);
AddXmlFormatterInWebApiConfig(proj);
var folderItem = VisualStudioAutomationHelper.AddFolderIfNotExists(proj, ContractsFolderName);
var generatedFolderPath = Path.GetDirectoryName(proj.FullName) + Path.DirectorySeparatorChar + ContractsFolderName + Path.DirectorySeparatorChar;
if (string.IsNullOrWhiteSpace(parameters.RamlSource) && !string.IsNullOrWhiteSpace(parameters.RamlTitle))
{
AddEmptyContract(parameters.TargetFileName, parameters.RamlTitle, folderItem, generatedFolderPath,
parameters.TargetNamespace, parameters.TargetFileName, parameters.UseAsyncMethods);
}
else
{
AddContractFromFile(parameters.RamlFilePath, parameters.TargetNamespace, parameters.RamlSource, folderItem,
generatedFolderPath, parameters.TargetFileName, parameters.UseAsyncMethods);
}
}
protected void AddEmptyContract(ProjectItem folderItem, string folderPath, RamlChooserActionParams parameters)
{
ThreadHelper.ThrowIfNotOnUIThread();
var newContractFile = Path.Combine(folderPath, parameters.TargetFileName);
var contents = CreateNewRamlContents(parameters.RamlTitle);
ProjectItem ramlProjItem;
if (File.Exists(newContractFile))
{
var dialogResult = InstallerServices.ShowConfirmationDialog(parameters.TargetFileName);
if (dialogResult == MessageBoxResult.Yes)
{
File.WriteAllText(newContractFile, contents);
ramlProjItem = folderItem.ProjectItems.AddFromFile(newContractFile);
}
else
{
#pragma warning disable VSTHRD010 // Invoke single-threaded types on Main thread
ramlProjItem = folderItem.ProjectItems.Cast <ProjectItem>().FirstOrDefault(i => i.Name == newContractFile);
#pragma warning restore VSTHRD010 // Invoke single-threaded types on Main thread
if (ramlProjItem == null)
{
ramlProjItem = folderItem.ProjectItems.AddFromFile(newContractFile);
}
}
}
else
{
File.WriteAllText(newContractFile, contents);
ramlProjItem = folderItem.ProjectItems.AddFromFile(newContractFile);
}
var props = Map(parameters);
var targetFolderPath = GetTargetFolderPath(folderPath, parameters.TargetFileName);
var refFilePath = InstallerServices.AddRefFile(newContractFile, targetFolderPath, parameters.TargetFileName, props);
ramlProjItem.ProjectItems.AddFromFile(refFilePath);
}
protected void AddUnitTests(ProjectItem folderItem, string folderPath, RamlChooserActionParams parameters)
{
Microsoft.VisualStudio.Shell.ThreadHelper.ThrowIfNotOnUIThread();
var includesFolderPath = folderPath + Path.DirectorySeparatorChar + InstallerServices.IncludesFolderName;
var includesManager = new RamlIncludesManager();
var result = includesManager.Manage(parameters.RamlSource, includesFolderPath, confirmOverrite: true, rootRamlPath: folderPath + Path.DirectorySeparatorChar);
ManageIncludes(folderItem, result);
var ramlProjItem = AddOrUpdateRamlFile(result.ModifiedContents, folderItem, folderPath, parameters.TargetFileName);
InstallerServices.RemoveSubItemsAndAssociatedFiles(ramlProjItem);
var targetFolderPath = GetTargetFolderPath(folderPath, parameters.TargetFileName);
RamlProperties props = Map(parameters);
var refFilePath = InstallerServices.AddRefFile(parameters.RamlFilePath, targetFolderPath, parameters.TargetFileName, props);
ramlProjItem.ProjectItems.AddFromFile(refFilePath);
Scaffold(ramlProjItem.FileNames[0], parameters);
}
protected void AddEmptyContract(ProjectItem folderItem, string folderPath, RamlChooserActionParams parameters)
{
var newContractFile = Path.Combine(folderPath, parameters.TargetFileName);
var contents = CreateNewRamlContents(parameters.RamlTitle);
ProjectItem ramlProjItem;
if (File.Exists(newContractFile))
{
var dialogResult = InstallerServices.ShowConfirmationDialog(parameters.TargetFileName);
if (dialogResult == MessageBoxResult.Yes)
{
File.WriteAllText(newContractFile, contents);
ramlProjItem = folderItem.ProjectItems.AddFromFile(newContractFile);
}
else
{
ramlProjItem = folderItem.ProjectItems.Cast <ProjectItem>().FirstOrDefault(i => i.Name == newContractFile);
if (ramlProjItem == null)
{
ramlProjItem = folderItem.ProjectItems.AddFromFile(newContractFile);
}
}
}
else
{
File.WriteAllText(newContractFile, contents);
ramlProjItem = folderItem.ProjectItems.AddFromFile(newContractFile);
}
var props = Map(parameters);
var targetFolderPath = GetTargetFolderPath(folderPath, parameters.TargetFileName);
var refFilePath = InstallerServices.AddRefFile(newContractFile, targetFolderPath, parameters.TargetFileName, props);
ramlProjItem.ProjectItems.AddFromFile(refFilePath);
}
public void Scaffold(string ramlSource, RamlChooserActionParams parameters)
{
var data = parameters.Data;
if (data == null || data.RamlDocument == null)
{
return;
}
var model = new WebApiGeneratorService(data.RamlDocument, parameters.ControllersNamespace, parameters.ModelsNamespace).BuildModel();
var dte = ServiceProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
var contractsFolderItem = VisualStudioAutomationHelper.AddFolderIfNotExists(proj, ContractsFolderName);
var ramlItem =
contractsFolderItem.ProjectItems.Cast <ProjectItem>()
.First(i => i.Name.ToLowerInvariant() == parameters.TargetFileName.ToLowerInvariant());
var contractsFolderPath = Path.GetDirectoryName(proj.FullName) + Path.DirectorySeparatorChar +
ContractsFolderName + Path.DirectorySeparatorChar;
var templates = new[]
{
ControllerBaseTemplateName,
ControllerInterfaceTemplateName,
ControllerImplementationTemplateName,
ModelTemplateName,
EnumTemplateName
};
if (!templatesManager.ConfirmWhenIncompatibleServerTemplate(contractsFolderPath, templates))
{
return;
}
var extensionPath = Path.GetDirectoryName(GetType().Assembly.Location) + Path.DirectorySeparatorChar;
AddOrUpdateModels(parameters, contractsFolderPath, ramlItem, model, contractsFolderItem, extensionPath);
AddOrUpdateEnums(parameters, contractsFolderPath, ramlItem, model, contractsFolderItem, extensionPath);
AddOrUpdateControllerBase(parameters, contractsFolderPath, ramlItem, model, contractsFolderItem, extensionPath);
AddOrUpdateControllerInterfaces(parameters, contractsFolderPath, ramlItem, model, contractsFolderItem, extensionPath);
AddOrUpdateControllerImplementations(parameters, contractsFolderPath, proj, model, contractsFolderItem, extensionPath);
AddJsonSchemaParsingErrors(model.Warnings, contractsFolderPath, contractsFolderItem, ramlItem);
if (parameters.GenerateUnitTests.HasValue && parameters.GenerateUnitTests.Value)
{
var testsProj = VisualStudioAutomationHelper.GetProject(dte, parameters.TestsProjectName);
parameters.TestsNamespace = VisualStudioAutomationHelper.GetDefaultNamespace(testsProj) + "." +
NetNamingMapper.GetObjectName(Path.GetFileNameWithoutExtension(parameters.RamlFilePath));
var unitTestsScaffoldService = UnitTestsScaffoldServiceBase.GetScaffoldService(Microsoft.VisualStudio.Shell.ServiceProvider.GlobalProvider);
unitTestsScaffoldService.InstallDependencies(testsProj);
unitTestsScaffoldService.ScaffoldToProject(parameters, testsProj);
}
}
public abstract void AddRamlReference(RamlChooserActionParams parameters);
public abstract void AddTests(RamlChooserActionParams parameters);
public abstract void AddContract(RamlChooserActionParams parameters);
public void Import()
{
StartProgress();
// DoEvents();
if (string.IsNullOrWhiteSpace(Namespace))
{
ShowErrorAndStopProgress("Error: you must specify a namespace.");
return;
}
if (!Filename.ToLowerInvariant().EndsWith(RamlFileExtension))
{
ShowErrorAndStopProgress("Error: the file must have the .raml extension.");
return;
}
if (!IsContractUseCase && !File.Exists(RamlTempFilePath))
{
ShowErrorAndStopProgress("Error: the specified file does not exist.");
return;
}
if (IsContractUseCase && UseApiVersion && string.IsNullOrWhiteSpace(ApiVersion))
{
ShowErrorAndStopProgress("Error: you need to specify a version.");
return;
}
if (IsContractUseCase && ConfigFolders && HasInvalidPath(ModelsFolder))
{
ShowErrorAndStopProgress("Error: invalid path specified for models. Path must be relative.");
//txtModels.Focus();
return;
}
if (IsContractUseCase && ConfigFolders && HasInvalidPath(ImplementationControllersFolder))
{
ShowErrorAndStopProgress("Error: invalid path specified for controllers. Path must be relative.");
//txtImplementationControllers.Focus();
return;
}
var path = Path.GetDirectoryName(GetType().Assembly.Location) + Path.DirectorySeparatorChar;
try
{
ResourcesPreview = "Processing. Please wait..." + Environment.NewLine + Environment.NewLine;
// Execute action (add RAML Reference, Scaffold Web Api, etc)
var parameters = new RamlChooserActionParams(RamlOriginalSource, RamlTempFilePath, RamlTitle, path,
Filename, Namespace, doNotScaffold: isNewContract);
if (isContractUseCase)
{
parameters.UseAsyncMethods = UseAsyncMethods;
parameters.IncludeApiVersionInRoutePrefix = UseApiVersion;
parameters.ImplementationControllersFolder = ImplementationControllersFolder;
parameters.ModelsFolder = ModelsFolder;
parameters.AddGeneratedSuffixToFiles = AddSuffixToGeneratedCode;
}
if (!isContractUseCase)
{
parameters.ClientRootClassName = ProxyClientName;
}
action(parameters);
ResourcesPreview += "Succeeded";
StopProgress();
CanImport = true;
WasImported = true;
TryClose();
}
catch (Exception ex)
{
ShowErrorAndStopProgress("Error: " + ex.Message);
ActivityLog.LogError(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource, VisualStudioAutomationHelper.GetExceptionInfo(ex));
}
}
