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 AddReverseEngineering()
{
try
{
ActivityLog.LogInformation(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource, "Enable RAML metadata output process started");
var dte = serviceProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
InstallNugetAndDependencies(proj);
ActivityLog.LogInformation(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource, "Nuget package and dependencies installed");
AddXmlCommentsDocumentation(proj);
ActivityLog.LogInformation(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource, "XML comments documentation added");
}
catch (Exception ex)
{
ActivityLog.LogError(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource,
VisualStudioAutomationHelper.GetExceptionInfo(ex));
MessageBox.Show("Error when trying to enable RAML metadata output. " + ex.Message);
throw;
}
}
public void RemoveReverseEngineering()
{
ThreadHelper.ThrowIfNotOnUIThread();
try
{
ActivityLog.LogInformation(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource, "Disable RAML metadata output process started");
var dte = serviceProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
UninstallNugetAndDependencies(proj);
ActivityLog.LogInformation(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource, "Nuget package uninstalled");
RemoveConfiguration(proj);
}
catch (Exception ex)
{
ActivityLog.LogError(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource,
VisualStudioAutomationHelper.GetExceptionInfo(ex));
MessageBox.Show("Error when trying to disable RAML metadata output. " + 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);
}
}
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);
}
private static IEnumerable <ProjectItem> GetMainRamlFileFromProject()
{
ThreadHelper.ThrowIfNotOnUIThread();
var dte = Microsoft.VisualStudio.Shell.ServiceProvider.GlobalProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
var contractsItem =
proj.ProjectItems.Cast <ProjectItem>().FirstOrDefault(i => i.Name == RAML.Tools.Properties.Settings.Default.ContractsFolderName);
if (contractsItem == null)
{
throw new InvalidOperationException("Could not find main file");
}
var ramlItems = contractsItem.ProjectItems.Cast <ProjectItem>().Where(i => !i.Name.EndsWith(".ref")).ToArray();
if (!ramlItems.Any())
{
throw new InvalidOperationException("Could not find main file");
}
return(ramlItems);
}
public override void AddTests(RamlChooserActionParams parameters)
{
ThreadHelper.ThrowIfNotOnUIThread();
Tracking.Track("Unit Tests Scaffold (Asp.Net WebApi)");
var dte = ServiceProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
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);
}
InstallDependencies(proj);
AddUnitTests(folderItem, contractsFolderPath, parameters);
}
private void InstallNugetDependencies(Project proj)
{
var packageVersion = VisualStudioAutomationHelper.IsAVisualStudio2015Project(proj) ? newtonsoftJsonForCorePackageVersion : newtonsoftJsonPackageVersion;
var componentModel = (IComponentModel)serviceProvider.GetService(typeof(SComponentModel));
var installerServices = componentModel.GetService <IVsPackageInstallerServices>();
var installer = componentModel.GetService <IVsPackageInstaller>();
var packs = installerServices.GetInstalledPackages(proj).ToArray();
// RAML.Api.Core dependencies
NugetInstallerHelper.InstallPackageIfNeeded(proj, packs, installer, newtonsoftJsonPackageId, packageVersion, Settings.Default.NugetExternalPackagesSource);
NugetInstallerHelper.InstallPackageIfNeeded(proj, packs, installer, microsoftNetHttpPackageId, microsoftNetHttpPackageVersion, Settings.Default.NugetExternalPackagesSource);
// System.Xml.XmlSerializer 4.0.11-beta-23516
// NugetInstallerHelper.InstallPackageIfNeeded(proj, packs, installer, "System.Xml.XmlSerializer", "4.0.11-beta-23516");
// RAML.Api.Core
if (!installerServices.IsPackageInstalled(proj, ramlApiCorePackageId))
{
installer.InstallPackage(nugetPackagesSource, proj, ramlApiCorePackageId, ramlApiCorePackageVersion, false);
}
}
public override void AddRamlReference(RamlChooserActionParams parameters)
{
ThreadHelper.ThrowIfNotOnUIThread();
try
{
Logger.LogInformation("Add RAML Reference process started");
Tracking.Track("API reference .Net Core");
var dte = ServiceProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
if (VisualStudioAutomationHelper.IsJsonOrXProj(proj))
{
AddPortableImports(proj);
}
InstallNugetDependencies(proj);
Logger.LogInformation("Nuget Dependencies installed");
AddFilesToProject(parameters.Data, 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 Scaffold(string ramlSource, string targetNamespace, string ramlFileName, bool useAsyncMethods)
{
var data = RamlScaffolderHelper.GetRamlData(ramlSource, 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 folderItem = VisualStudioAutomationHelper.AddFolderIfNotExists(proj, ContractsFolderName);
var ramlItem = folderItem.ProjectItems.Cast <ProjectItem>().First(i => i.Name.ToLowerInvariant() == ramlFileName.ToLowerInvariant());
var generatedFolderPath = Path.GetDirectoryName(proj.FullName) + Path.DirectorySeparatorChar + ContractsFolderName + Path.DirectorySeparatorChar;
if (!templatesManager.ConfirmWhenIncompatibleServerTemplate(generatedFolderPath,
new[] { ControllerBaseTemplateName, ControllerInterfaceTemplateName, ControllerImplementationTemplateName, ModelTemplateName, EnumTemplateName }))
{
return;
}
var extensionPath = Path.GetDirectoryName(GetType().Assembly.Location) + Path.DirectorySeparatorChar;
AddOrUpdateModels(targetNamespace, generatedFolderPath, ramlItem, model, folderItem, extensionPath);
AddOrUpdateEnums(targetNamespace, generatedFolderPath, ramlItem, model, folderItem, extensionPath);
AddOrUpdateControllerBase(targetNamespace, generatedFolderPath, ramlItem, model, folderItem, extensionPath, useAsyncMethods);
AddOrUpdateControllerInterfaces(targetNamespace, generatedFolderPath, ramlItem, model, folderItem, extensionPath, useAsyncMethods);
AddOrUpdateControllerImplementations(targetNamespace, generatedFolderPath, proj, model, folderItem, extensionPath, useAsyncMethods);
}
private void SetPreview(RamlDocument document)
{
Execute.OnUIThreadAsync(() =>
{
try
{
ResourcesPreview = GetResourcesPreview(document);
StopProgress();
SetNamespace(RamlTempFilePath);
if (document.Version != null)
{
ApiVersion = NetNamingMapper.GetVersionName(document.Version);
}
CanImport = true;
if (NetNamingMapper.HasIndalidChars(Filename))
{
ShowErrorAndStopProgress("The specied file name has invalid chars");
// txtFileName.Focus();
}
}
catch (Exception ex)
{
ShowErrorAndStopProgress("Error while parsing raml file. " + ex.Message);
ActivityLog.LogError(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource, VisualStudioAutomationHelper.GetExceptionInfo(ex));
}
});
}
public int Generate(string wszInputFilePath, string bstrInputFileContents, string wszDefaultNamespace,
IntPtr[] rgbOutputFileContents, out uint pcbOutput, IVsGeneratorProgress pGenerateProgress)
{
try
{
if (bstrInputFileContents == null)
{
throw new ArgumentNullException("bstrInputFileContents");
}
var containingFolder = Path.GetDirectoryName(wszInputFilePath);
var refFilePath = InstallerServices.GetRefFilePath(wszInputFilePath);
var ramlSource = RamlReferenceReader.GetRamlSource(refFilePath);
var clientRootClassName = RamlReferenceReader.GetClientRootClassName(refFilePath);
var globalProvider = ServiceProvider.GlobalProvider;
var destFolderItem = GetDestinationFolderItem(wszInputFilePath, globalProvider);
var result = UpdateRamlAndIncludedFiles(wszInputFilePath, destFolderItem, ramlSource, containingFolder);
if (!result.IsSuccess)
{
MessageBox.Show("Error when tryng to download " + ramlSource + " - Status Code: " + Enum.GetName(typeof(HttpStatusCode), result.StatusCode));
pcbOutput = 0;
return(VSConstants.E_ABORT);
}
var dte = ServiceProvider.GlobalProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
var apiRefsFolderPath = Path.GetDirectoryName(proj.FullName) + Path.DirectorySeparatorChar +
RamlReferenceService.ApiReferencesFolderName + Path.DirectorySeparatorChar;
templatesManager.CopyClientTemplateToProjectFolder(apiRefsFolderPath);
var ramlInfo = RamlInfoService.GetRamlInfo(wszInputFilePath);
if (ramlInfo.HasErrors)
{
MessageBox.Show(ramlInfo.ErrorMessage);
pcbOutput = 0;
return(VSConstants.E_ABORT);
}
var res = GenerateCodeUsingTemplate(wszInputFilePath, ramlInfo, globalProvider, refFilePath, clientRootClassName);
if (res.HasErrors)
{
ActivityLog.LogError(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource, res.Errors);
MessageBox.Show(res.Errors);
pcbOutput = 0;
return(VSConstants.E_ABORT);
}
var content = templatesManager.AddClientMetadataHeader(res.Content);
var bytes = Encoding.UTF8.GetBytes(content);
rgbOutputFileContents[0] = Marshal.AllocCoTaskMem(bytes.Length);
Marshal.Copy(bytes, 0, rgbOutputFileContents[0], bytes.Length);
pcbOutput = (uint)bytes.Length;
return(VSConstants.S_OK);
}
catch (Exception ex)
{
ActivityLog.LogError(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource,
VisualStudioAutomationHelper.GetExceptionInfo(ex));
var errorMessage = ex.Message;
if (ex.InnerException != null)
{
errorMessage += " - " + ex.InnerException.Message;
}
MessageBox.Show(errorMessage);
pcbOutput = 0;
return(VSConstants.E_ABORT);
}
}
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 void LogError(Exception ex)
{
ActivityLog.LogError(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource, VisualStudioAutomationHelper.GetExceptionInfo(ex));
}
private void SetNamespace(string fileName)
{
Namespace = VisualStudioAutomationHelper.GetDefaultNamespace(ServiceProvider) + "." +
NetNamingMapper.GetObjectName(Path.GetFileNameWithoutExtension(fileName));
}
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));
}
}
private static void ShowOrHideUpdateRamlRefCommand(object sender, string containingFolderName)
{
// get the menu that fired the event
var menuCommand = sender as OleMenuCommand;
if (menuCommand == null)
{
return;
}
ShowAndEnableCommand(menuCommand, false);
var dte = ServiceProvider.GlobalProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
if (VisualStudioAutomationHelper.IsAVisualStudio2015Project(proj))
{
return;
}
IVsHierarchy hierarchy;
uint itemid;
if (!IsSingleProjectItemSelection(out hierarchy, out itemid))
{
return;
}
// Get the file path
string itemFullPath;
((IVsProject)hierarchy).GetMkDocument(itemid, out itemFullPath);
FileInfo transformFileInfo;
try
{
transformFileInfo = new FileInfo(itemFullPath);
}
catch (Exception)
{
return;
}
var endsWithExtension = transformFileInfo.Name.EndsWith(".raml");
// if not leave the menu hidden
if (!endsWithExtension)
{
return;
}
if (!itemFullPath.Contains(containingFolderName))
{
return;
}
var folder = Path.GetDirectoryName(itemFullPath);
if (folder.EndsWith(InstallerServices.IncludesFolderName))
{
return;
}
var refFile = InstallerServices.GetRefFilePath(itemFullPath);
var source = RamlReferenceReader.GetRamlSource(refFile);
if (string.IsNullOrWhiteSpace(source))
{
return;
}
ShowAndEnableCommand(menuCommand, true);
}
