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);
}
}
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 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);
}
}
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);
}
}
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);
}
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);
}
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 bool IsAVisualStudio2015Project()
{
var dte = ServiceProvider.GlobalProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
return(VisualStudioAutomationHelper.IsAVisualStudio2015Project(proj));
}
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 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 void BeforeQueryStatus(object sender, EventArgs e)
{
var menuCommand = sender as OleMenuCommand;
if (menuCommand == null)
{
return;
}
CommandsUtil.ShowAndEnableCommand(menuCommand, false);
var dte = Microsoft.VisualStudio.Shell.ServiceProvider.GlobalProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
if (!VisualStudioAutomationHelper.IsANetCoreProject(proj) && (!CommandsUtil.IsWebApiCoreInstalled(proj) || IsWebApiExplorerInstalled()))
{
return;
}
if (VisualStudioAutomationHelper.IsANetCoreProject(proj) && (!CommandsUtil.IsAspNet5MvcInstalled(proj) || IsNetCoreApiExplorerInstalled()))
{
return;
}
CommandsUtil.ShowAndEnableCommand(menuCommand, true);
}
private static bool IsMsTestsInstalled()
{
var dte = Microsoft.VisualStudio.Shell.ServiceProvider.GlobalProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
return(CommandsUtil.IsPackageInstalled(proj, "MSTest.TestFramework"));
}
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 bool IsNetCoreApiExplorerInstalled()
{
var dte = ServiceProvider.GlobalProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
var componentModel = (IComponentModel)ServiceProvider.GlobalProvider.GetService(typeof(SComponentModel));
var installerServices = componentModel.GetService <IVsPackageInstallerServices>();
var isWebApiCoreInstalled = installerServices.IsPackageInstalled(proj, "RAML.NetCoreApiExplorer");
return(isWebApiCoreInstalled);
}
private static bool IsWebApiCoreInstalled()
{
var dte = ServiceProvider.GlobalProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
var componentModel = (IComponentModel)ServiceProvider.GlobalProvider.GetService(typeof(SComponentModel));
var installerServices = componentModel.GetService <IVsPackageInstallerServices>();
var isWebApiCoreInstalled = installerServices.IsPackageInstalled(proj, "Microsoft.AspNet.WebApi.Core");
return(isWebApiCoreInstalled);
}
private static bool IsAspNet5OrWebApiCoreInstalled()
{
var proj = VisualStudioAutomationHelper.GetActiveProject(_dte);
if (VisualStudioAutomationHelper.IsANetCoreProject(proj))
{
return(CommandsUtil.IsAspNet5MvcInstalled(proj));
}
return(CommandsUtil.IsWebApiCoreInstalled(proj));
}
private static ProjectItem GetDestinationFolderItem(string wszInputFilePath, System.IServiceProvider globalProvider)
{
var destFolderName = Path.GetFileNameWithoutExtension(wszInputFilePath);
var dte = globalProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
var apiRefsFolderItem =
proj.ProjectItems.Cast <ProjectItem>().First(i => i.Name == RamlReferenceService.ApiReferencesFolderName);
var destFolderItem = apiRefsFolderItem.ProjectItems.Cast <ProjectItem>().First(i => i.Name == destFolderName);
return(destFolderItem);
}
private bool IsWebApiExplorerInstalled()
{
ThreadHelper.ThrowIfNotOnUIThread();
var proj = VisualStudioAutomationHelper.GetActiveProject(_dte);
var componentModel = (IComponentModel)Microsoft.VisualStudio.Shell.ServiceProvider.GlobalProvider.GetService(typeof(SComponentModel));
var installerServices = componentModel.GetService <IVsPackageInstallerServices>();
var isWebApiCoreInstalled = installerServices.IsPackageInstalled(proj, "RAML.WebApiExplorer");
return(isWebApiCoreInstalled);
}
private RamlPreviewViewModel(IServiceProvider serviceProvider, string ramlTitle, bool useBasicAuth, string username, string password)
{
ServiceProvider = serviceProvider;
RamlTitle = ramlTitle;
var dte = serviceProvider.GetService(typeof(SDTE)) as DTE;
Projects = VisualStudioAutomationHelper.GetProjects(dte);
activeProjectName = VisualStudioAutomationHelper.GetActiveProject(dte).Name;
this.useBasicAuth = useBasicAuth;
this.username = username;
this.password = password;
}
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));
}
private static bool IsAspNet5OrWebApiCoreInstalled()
{
var dte = Microsoft.VisualStudio.Shell.ServiceProvider.GlobalProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
if (VisualStudioAutomationHelper.IsANetCoreProject(proj))
{
return(CommandsUtil.IsAspNet5MvcInstalled(proj));
}
return(CommandsUtil.IsWebApiCoreInstalled(proj));
}
public static CodeRegenerationResult RegenerateCode(string ramlFilePath, string extensionPath)
{
var containingFolder = Path.GetDirectoryName(ramlFilePath);
var refFilePath = InstallerServices.GetRefFilePath(ramlFilePath);
var ramlSource = RamlReferenceReader.GetRamlSource(refFilePath);
if (string.IsNullOrWhiteSpace(ramlSource))
{
ramlSource = ramlFilePath;
}
var clientRootClassName = RamlReferenceReader.GetClientRootClassName(refFilePath);
var globalProvider = ServiceProvider.GlobalProvider;
var destFolderItem = GetDestinationFolderItem(ramlFilePath, globalProvider);
var result = UpdateRamlAndIncludedFiles(ramlFilePath, destFolderItem, ramlSource, containingFolder);
if (!result.IsSuccess)
{
return(CodeRegenerationResult.Error("Error when tryng to download " + ramlSource + " - Status Code: " + Enum.GetName(typeof(HttpStatusCode), result.StatusCode)));
}
var dte = ServiceProvider.GlobalProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
var apiRefsFolderPath = Path.GetDirectoryName(proj.FullName) + Path.DirectorySeparatorChar +
RamlReferenceServiceBase.ApiReferencesFolderName + Path.DirectorySeparatorChar;
TemplatesManager.CopyClientTemplateToProjectFolder(apiRefsFolderPath);
var ramlInfo = RamlInfoService.GetRamlInfo(ramlFilePath);
if (ramlInfo.HasErrors)
{
return(CodeRegenerationResult.Error(ramlInfo.ErrorMessage));
}
var res = GenerateCodeUsingTemplate(ramlFilePath, ramlInfo, globalProvider, refFilePath, clientRootClassName, extensionPath);
if (res.HasErrors)
{
return(CodeRegenerationResult.Error(res.Errors));
}
var content = TemplatesManager.AddClientMetadataHeader(res.Content);
return(CodeRegenerationResult.Success(content));
}
public static ReverseEngineeringServiceBase GetReverseEngineeringService(ServiceProvider serviceProvider)
{
var dte = serviceProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
ReverseEngineeringServiceBase service;
if (VisualStudioAutomationHelper.IsANetCoreProject(proj))
{
service = new ReverseEngineeringAspNetCore(serviceProvider);
}
else
{
service = new ReverseEngineeringServiceWebApi(serviceProvider);
}
return(service);
}
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);
}
public static RamlScaffoldServiceBase GetRamlScaffoldService(ServiceProvider serviceProvider)
{
var dte = serviceProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
RamlScaffoldServiceBase service;
if (VisualStudioAutomationHelper.IsANetCoreProject(proj))
{
service = new RamlScaffoldServiceAspNetCore(new T4Service(serviceProvider), serviceProvider);
}
else
{
service = new RamlScaffoldServiceWebApi(new T4Service(serviceProvider), serviceProvider);
}
return(service);
}
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);
}
}
public static UnitTestsScaffoldServiceBase GetScaffoldService(Microsoft.VisualStudio.Shell.ServiceProvider serviceProvider)
{
Microsoft.VisualStudio.Shell.ThreadHelper.ThrowIfNotOnUIThread();
var dte = serviceProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
UnitTestsScaffoldServiceBase service;
if (VisualStudioAutomationHelper.IsANetCoreProject(proj))
{
service = new UnitTestsScaffoldServiceAspNetCore(new T4Service(serviceProvider), serviceProvider);
}
else
{
service = new UnitTestsScaffoldServiceAspNetWebApi(new T4Service(serviceProvider), serviceProvider);
}
return(service);
}
public void Scaffold(string ramlSource, string targetNamespace, string ramlFileName)
{
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, folderName);
var ramlItem = folderItem.ProjectItems.Cast <ProjectItem>().First(i => i.Name == ramlFileName);
var generatedFolderPath = Path.GetDirectoryName(proj.FullName) + Path.DirectorySeparatorChar + folderName + Path.DirectorySeparatorChar;
var vsixPath = Path.GetDirectoryName(GetType().Assembly.Location) + Path.DirectorySeparatorChar;
var templatesPath = vsixPath + "Templates" + Path.DirectorySeparatorChar + "RAMLWebApi2Scaffolder" + Path.DirectorySeparatorChar;
// Add / Update model objects
ReplaceTemplateValues(templatesPath, vsixPath, ObjectTemplateName + ".t4", targetNamespace);
GenerateCodeFromTemplate(Path.Combine(templatesPath, ObjectTemplateName + ".cs.t4"), ramlItem,
"apiObject", model.Objects.Values, generatedFolderPath, folderItem);
// Add / Update controllers definition
ReplaceTemplateValues(templatesPath, vsixPath, ControllerDeclarationTemplateName + ".t4", targetNamespace);
GenerateCodeFromTemplate(Path.Combine(templatesPath, ControllerDeclarationTemplateName + ".cs.t4"), ramlItem,
"controllerObject", model.Controllers, generatedFolderPath, folderItem, "Controller");
// Add / Update controllers interface
ReplaceTemplateValues(templatesPath, vsixPath, ControllerInterfaceTemplateName + ".t4", targetNamespace);
GenerateCodeFromTemplate(Path.Combine(templatesPath, ControllerInterfaceTemplateName + ".cs.t4"), ramlItem,
"controllerObject", model.Controllers, generatedFolderPath, folderItem, "Controller", true, "I");
// Add controllers implementation
var controllersFolderItem = VisualStudioAutomationHelper.AddFolderIfNotExists(proj, "Controllers");
var controllersFolderPath = Path.GetDirectoryName(proj.FullName) + Path.DirectorySeparatorChar + "Controllers" + Path.DirectorySeparatorChar;
ReplaceTemplateValues(templatesPath, vsixPath, ControllerImplementationTemplateName + ".t4", targetNamespace);
GenerateCodeFromTemplate(Path.Combine(templatesPath, ControllerImplementationTemplateName + ".cs.t4"), controllersFolderItem,
"controllerObject", model.Controllers, controllersFolderPath, folderItem, "Controller", false);
}
public void UpdateRaml(string ramlFilePath)
{
var dte = serviceProvider.GetService(typeof(SDTE)) as DTE;
var proj = VisualStudioAutomationHelper.GetActiveProject(dte);
var generatedFolderPath = Path.GetDirectoryName(proj.FullName) + Path.DirectorySeparatorChar + ContractsFolderName + Path.DirectorySeparatorChar;
var refFilePath = InstallerServices.GetRefFilePath(ramlFilePath);
var includesFolderPath = generatedFolderPath + Path.DirectorySeparatorChar + InstallerServices.IncludesFolderName;
var ramlSource = RamlReferenceReader.GetRamlSource(refFilePath);
var includesManager = new RamlIncludesManager();
var result = includesManager.Manage(ramlSource, includesFolderPath, generatedFolderPath + Path.DirectorySeparatorChar);
if (result.IsSuccess)
{
File.WriteAllText(ramlFilePath, result.ModifiedContents);
var targetNamespace = RamlReferenceReader.GetRamlNamespace(refFilePath);
var useAsyncMethods = RamlReferenceReader.GetRamlUseAsyncMethods(refFilePath);
Scaffold(ramlFilePath, targetNamespace, Path.GetFileName(ramlFilePath).ToLowerInvariant(), useAsyncMethods);
}
}
