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);
}
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 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 AddOrUpdateEnums(string targetNamespace, string generatedFolderPath, ProjectItem ramlItem,
WebApiGeneratorModel model, ProjectItem folderItem, string extensionPath)
{
templatesManager.CopyServerTemplateToProjectFolder(generatedFolderPath, EnumTemplateName,
Settings.Default.EnumsTemplateTitle);
var templatesFolder = Path.Combine(generatedFolderPath, "Templates");
var apiEnumTemplateParams = new TemplateParams <ApiEnum>(
Path.Combine(templatesFolder, EnumTemplateName), ramlItem, "apiEnum", model.Enums,
generatedFolderPath, folderItem, extensionPath, targetNamespace);
apiEnumTemplateParams.Title = Settings.Default.ModelsTemplateTitle;
GenerateCodeFromTemplate(apiEnumTemplateParams);
}
private void AddOrUpdateControllerBase(string targetNamespace, string generatedFolderPath, ProjectItem ramlItem,
WebApiGeneratorModel model, ProjectItem folderItem, string extensionPath, bool useAsyncMethods)
{
templatesManager.CopyServerTemplateToProjectFolder(generatedFolderPath, ControllerBaseTemplateName,
Settings.Default.BaseControllerTemplateTitle);
var templatesFolder = Path.Combine(generatedFolderPath, "Templates");
var controllerBaseTemplateParams =
new TemplateParams <ControllerObject>(Path.Combine(templatesFolder, ControllerBaseTemplateName),
ramlItem, "controllerObject", model.Controllers, generatedFolderPath, folderItem, extensionPath,
targetNamespace, "Controller");
controllerBaseTemplateParams.Title = Settings.Default.BaseControllerTemplateTitle;
controllerBaseTemplateParams.IncludeHasModels = true;
controllerBaseTemplateParams.HasModels = model.Objects.Any() || model.Enums.Any();
controllerBaseTemplateParams.UseAsyncMethods = useAsyncMethods;
GenerateCodeFromTemplate(controllerBaseTemplateParams);
}
private void AddOrUpdateControllerImplementations(string targetNamespace, string generatedFolderPath, Project proj,
WebApiGeneratorModel model, ProjectItem folderItem, string extensionPath, bool useAsyncMethods)
{
templatesManager.CopyServerTemplateToProjectFolder(generatedFolderPath, ControllerImplementationTemplateName,
Settings.Default.ControllerImplementationTemplateTitle);
var controllersFolderItem = VisualStudioAutomationHelper.AddFolderIfNotExists(proj, "Controllers");
var controllersFolderPath = Path.GetDirectoryName(proj.FullName) + Path.DirectorySeparatorChar + "Controllers" +
Path.DirectorySeparatorChar;
var templatesFolder = Path.Combine(generatedFolderPath, "Templates");
var controllerImplementationTemplateParams =
new TemplateParams <ControllerObject>(Path.Combine(templatesFolder, ControllerImplementationTemplateName),
controllersFolderItem, "controllerObject", model.Controllers, controllersFolderPath, folderItem,
extensionPath, targetNamespace, "Controller", false);
controllerImplementationTemplateParams.Title = Settings.Default.ControllerImplementationTemplateTitle;
controllerImplementationTemplateParams.IncludeHasModels = true;
controllerImplementationTemplateParams.HasModels = model.Objects.Any() || model.Enums.Any();
controllerImplementationTemplateParams.UseAsyncMethods = useAsyncMethods;
GenerateCodeFromTemplate(controllerImplementationTemplateParams);
}
public void WebApiGeneratorModelTest()
{
IncrementTestCount();
var model = new WebApiGeneratorModel()
{
ApiVersion = "v1",
BaseUri = "www.base.com",
BaseUriParameters = new List <GeneratorParameter>()
{
new GeneratorParameter()
{
Name = "pepe", Type = "string"
}
},
Controllers = new List <ControllerObject>(),
ControllersNamespace = "ns",
Security = new Security()
};
Assert.AreEqual("string pepe", model.BaseUriParametersString);
}
private void AddOrUpdateModels(string targetNamespace, string generatedFolderPath, ProjectItem ramlItem,
WebApiGeneratorModel model, ProjectItem folderItem, string extensionPath)
{
templatesManager.CopyServerTemplateToProjectFolder(generatedFolderPath, ModelTemplateName,
Settings.Default.ModelsTemplateTitle);
var templatesFolder = Path.Combine(generatedFolderPath, "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
var apiObjectTemplateParams = new TemplateParams <ApiObject>(
Path.Combine(templatesFolder, ModelTemplateName), ramlItem, "apiObject", models,
generatedFolderPath, folderItem, extensionPath, targetNamespace);
apiObjectTemplateParams.Title = Settings.Default.ModelsTemplateTitle;
GenerateCodeFromTemplate(apiObjectTemplateParams);
}
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 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 RamlData(WebApiGeneratorModel model, string ramlContent, string filename)
{
Model = model;
RamlContent = ramlContent;
Filename = filename;
}
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));
}
// 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 = Settings.Default.ModelsTemplateTitle,
RelativeFolder = parameters.ModelsFolder,
TargetFolder = TargetFolderResolver.GetModelsTargetFolder(ramlItem.ContainingProject,
targetFolderPath, parameters.ModelsFolder),
ModelsNamespace = parameters.ModelsNamespace
};
codeGenerator.GenerateCodeFromTemplate(apiObjectTemplateParams);
}
