private static bool IsAlreadyIncludedInProject(string folderPath, ProjectItem folderItem, string generatedFileName, ProjectItem fileItem)
{
if (VisualStudioAutomationHelper.IsAVisualStudio2015Project(fileItem.ContainingProject))
{
return(File.Exists(Path.Combine(folderPath, generatedFileName)));
}
var otherRamlFiles = GetOtherRamlFilesInProject(folderPath, fileItem);
var alreadyIncludedInProj = false;
foreach (var ramlFile in otherRamlFiles)
{
var fileName = Path.GetFileName(ramlFile);
var otherRamlFileItem =
folderItem.ProjectItems.Cast <ProjectItem>().FirstOrDefault(i => i.Name == fileName);
if (otherRamlFileItem == null)
{
continue;
}
var item = otherRamlFileItem.ProjectItems.Cast <ProjectItem>().FirstOrDefault(i => i.Name == generatedFileName);
alreadyIncludedInProj = alreadyIncludedInProj || (item != null);
}
return(alreadyIncludedInProj);
}
private void RemoveReverseEngineeringCommandOnBeforeQueryStatus(object sender, EventArgs e)
{
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;
}
if (!IsWebApiExplorerInstalled())
{
return;
}
ShowAndEnableCommand(menuCommand, true);
}
private void ExtractRAMLCommandOnBeforeQueryStatus(object sender, EventArgs e)
{
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) && !IsWebApiCoreInstalled(proj))
{
return;
}
if (VisualStudioAutomationHelper.IsAVisualStudio2015Project(proj) && !IsAspNet5MvcInstalled(proj))
{
return;
}
ShowAndEnableCommand(menuCommand, true);
}
private static bool IsAVisualStudio2015Project()
{
var dte = ServiceProvider.GlobalProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
return(VisualStudioAutomationHelper.IsAVisualStudio2015Project(proj));
}
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);
}
}
private static void ShowOrHideCommandForFolder(object sender, string folderName)
{
// get the menu that fired the event
var menuCommand = sender as OleMenuCommand;
if (menuCommand == null)
{
return;
}
ShowAndEnableCommand(menuCommand, false);
if (IsInFolder(folderName))
{
return;
}
var dte = ServiceProvider.GlobalProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
if (VisualStudioAutomationHelper.IsAVisualStudio2015Project(proj) && !IsAspNet5MvcInstalled(proj))
{
return;
}
ShowAndEnableCommand(menuCommand, true);
}
private static void ShowOrHideForFolderIfNotVs2015(object sender, string folderName)
{
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;
}
if (IsInFolder(folderName))
{
return;
}
ShowAndEnableCommand(menuCommand, true);
}
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 static string GetTargetFolderPath(string folderPath, string targetFilename, Project proj)
{
var targetFolderPath = folderPath;
if (VisualStudioAutomationHelper.IsAVisualStudio2015Project(proj))
{
targetFolderPath += Path.GetFileNameWithoutExtension(targetFilename) + Path.DirectorySeparatorChar;
}
return(targetFolderPath);
}
private static bool IsAspNet5OrWebApiCoreInstalled()
{
var dte = ServiceProvider.GlobalProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
if (VisualStudioAutomationHelper.IsAVisualStudio2015Project(proj))
{
return(IsAspNet5MvcInstalled(proj));
}
return(IsWebApiCoreInstalled(proj));
}
public static RamlReferenceServiceBase GetRamlReferenceService(ServiceProvider serviceProvider, ILogger logger)
{
var dte = serviceProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
RamlReferenceServiceBase service;
if (VisualStudioAutomationHelper.IsAVisualStudio2015Project(proj))
{
service = new RamlReferenceServiceNetCore(serviceProvider, logger);
}
else
{
service = new RamlReferenceServiceNetFramework(serviceProvider, logger);
}
return(service);
}
private static void AddFileToProject(ProjectItem contractsFolderItem, string fileName, string file)
{
if (VisualStudioAutomationHelper.IsAVisualStudio2015Project(contractsFolderItem.ContainingProject))
{
return;
}
var fileItem = contractsFolderItem.ProjectItems.Cast <ProjectItem>().FirstOrDefault(i => i.Name == fileName);
if (fileItem != null)
{
return;
}
contractsFolderItem.ProjectItems.AddFromFile(file);
}
public static RamlScaffoldServiceBase GetRamlScaffoldService(ServiceProvider serviceProvider)
{
var dte = serviceProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
RamlScaffoldServiceBase service;
if (VisualStudioAutomationHelper.IsAVisualStudio2015Project(proj))
{
service = new RamlScaffoldServiceAspNetCore(new T4Service(serviceProvider), serviceProvider);
}
else
{
service = new RamlScaffoldServiceWebApi(new T4Service(serviceProvider), serviceProvider);
}
return(service);
}
public static ReverseEngineeringServiceBase GetReverseEngineeringService(ServiceProvider serviceProvider)
{
var dte = serviceProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
ReverseEngineeringServiceBase service;
if (VisualStudioAutomationHelper.IsAVisualStudio2015Project(proj))
{
service = new ReverseEngineeringAspNetCore(serviceProvider);
}
else
{
service = new ReverseEngineeringServiceWebApi(serviceProvider);
}
return(service);
}
public void GenerateCodeFromTemplate <T>(RamlScaffoldService.TemplateParams <T> templateParams) where T : IHasName
{
if (!Directory.Exists(templateParams.TargetFolder))
{
Directory.CreateDirectory(templateParams.TargetFolder);
}
foreach (var parameter in templateParams.ParameterCollection)
{
var generatedFileName = GetGeneratedFileName(templateParams.Suffix, templateParams.Prefix, parameter);
var destinationFile = Path.Combine(templateParams.TargetFolder, generatedFileName);
var result = t4Service.TransformText(templateParams.TemplatePath, templateParams.ParameterName, parameter, templateParams.BinPath, templateParams.TargetNamespace,
templateParams.UseAsyncMethods, templateParams.IncludeHasModels, templateParams.HasModels, templateParams.IncludeApiVersionInRoutePrefix, templateParams.ApiVersion);
var contents = templatesManager.AddServerMetadataHeader(result.Content, Path.GetFileNameWithoutExtension(templateParams.TemplatePath), templateParams.Title);
if (templateParams.Ovewrite || !File.Exists(destinationFile))
{
File.WriteAllText(destinationFile, contents);
}
if (templateParams.ParameterName == "controllerObject" || templateParams.TargetFolder == templateParams.FolderPath)
{
// add file if it does not exist
var fileItem = templateParams.ProjItem.ProjectItems.Cast <ProjectItem>()
.FirstOrDefault(i => i.Name == generatedFileName);
if (fileItem != null)
{
continue;
}
// var alreadyIncludedInProj = IsAlreadyIncludedInProject(templateParams.FolderPath, templateParams.FolderItem, generatedFileName, templateParams.ProjItem);
//if (!alreadyIncludedInProj)
if (!VisualStudioAutomationHelper.IsAVisualStudio2015Project(templateParams.FolderItem.ContainingProject))
{
templateParams.ProjItem.ProjectItems.AddFromFile(destinationFile);
}
}
else
{
var folder = templateParams.TargetFolder.TrimEnd(Path.DirectorySeparatorChar);
var proj = templateParams.ProjItem.ContainingProject;
AddItem(folder, proj, generatedFileName, destinationFile, templateParams.RelativeFolder);
}
}
}
private static ProjectItem CreateFolderItem(Project proj, string path, string relativeFolder)
{
if (ContainsSubFolders(relativeFolder))
{
var folders = relativeFolder.Split(PossibleDirectorySeparatorChars);
var folderItem = VisualStudioAutomationHelper.AddFolderIfNotExists(proj, folders[0]);
return(CreateFolderItem(folderItem, folders, 1));
}
if (VisualStudioAutomationHelper.IsAVisualStudio2015Project(proj))
{
return(null);
}
var folderName = path.Substring(path.LastIndexOf(Path.DirectorySeparatorChar) + 1);
return(VisualStudioAutomationHelper.AddFolderIfNotExists(proj, folderName));
}
private void AddRamlRefCommandOnBeforeQueryStatus(object sender, EventArgs eventArgs)
{
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;
}
ShowAndEnableCommand(menuCommand, true);
}
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 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);
}
}
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);
}