private static async Task <ClientGeneratorModel> GetEpiGeneratedModel()
{
var raml = await new RamlParser().LoadAsync("epi.raml");
var model = new ClientGeneratorService(raml, "EpiApi").BuildModel();
return(model);
}
public override void GenerateCode(RamlInfo data, Project proj, string targetNamespace, string clientRootClassName,
string apiRefsFolderPath, string ramlDestFile, string destFolderPath, string destFolderName, ProjectItem ramlProjItem)
{
//ramlProjItem.Properties.Item("CustomTool").Value = string.Empty; // to cause a refresh when file already exists
//ramlProjItem.Properties.Item("CustomTool").Value = "RamlClientTool";
var model = new ClientGeneratorService(data.RamlDocument, clientRootClassName, targetNamespace, targetNamespace + ".Models").BuildModel();
var directoryName = Path.GetDirectoryName(ramlDestFile).TrimEnd(Path.DirectorySeparatorChar);
var templateFolder = directoryName.Substring(0, directoryName.LastIndexOf(Path.DirectorySeparatorChar)) +
Path.DirectorySeparatorChar + "Templates" + Path.DirectorySeparatorChar;
var templateFilePath = Path.Combine(templateFolder, ClientT4TemplateName);
var extensionPath = Path.GetDirectoryName(GetType().Assembly.Location) + Path.DirectorySeparatorChar;
TemplatesManager.CopyClientTemplateToProjectFolder(apiRefsFolderPath, "Client");
var t4Service = new T4Service(ServiceProvider);
var res = t4Service.TransformText(templateFilePath, model, extensionPath, ramlDestFile, targetNamespace);
if (res.HasErrors)
{
ActivityLog.LogError(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource, res.Errors);
MessageBox.Show(res.Errors);
}
else
{
var content = TemplatesManager.AddClientMetadataHeader(res.Content);
var csTargetFile = Path.Combine(destFolderPath, destFolderName + ".cs");
File.WriteAllText(csTargetFile, content);
ramlProjItem.ProjectItems.AddFromFile(csTargetFile);
}
}
private static async Task <ClientGeneratorModel> GetSameNameGeneratedModel()
{
var raml = await new RamlParser().LoadAsync("files/same-name-dif-obj.raml");
var model = new ClientGeneratorService(raml, "SameName", "TargetNamespace").BuildModel();
return(model);
}
private static async Task <ClientGeneratorModel> GetPatchGeneratedModel()
{
var raml = await new RamlParser().LoadAsync("files/patch.raml");
var model = new ClientGeneratorService(raml, "Patch", "TargetNamespace").BuildModel();
return(model);
}
private static async Task <ClientGeneratorModel> GetSchemaTestsGeneratedModel()
{
var raml = await new RamlParser().LoadAsync("files/schematests.raml");
var model = new ClientGeneratorService(raml, "SchemaTest", "NsTest").BuildModel();
return(model);
}
private static async Task <ClientGeneratorModel> GetExternalRefsGeneratedModel()
{
var raml = await new RamlParser().LoadAsync("files/external-refs.raml");
var model = new ClientGeneratorService(raml, "ExternalRefs", "TargetNamespace").BuildModel();
return(model);
}
private static async Task <ClientGeneratorModel> GetDarsWithParamsGeneratedModel()
{
var raml = await new RamlParser().LoadAsync("files/darsparam.raml");
var model = new ClientGeneratorService(raml, "DarsApi", "TargetNamespace").BuildModel();
return(model);
}
private static async Task <ClientGeneratorModel> GetFstabGeneratedModel()
{
var raml = await new RamlParser().LoadAsync("files/fstab.raml");
var model = new ClientGeneratorService(raml, "FstabApi", "NsTest").BuildModel();
return(model);
}
private void GenerateCode(string targetNamespace, string clientRootClassName, string ramlDestFile, string destFolderPath,
string destFolderName)
{
var ramlInfo = RamlInfoService.GetRamlInfo(ramlDestFile);
if (ramlInfo.HasErrors)
{
ActivityLog.LogError(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource, ramlInfo.ErrorMessage);
MessageBox.Show(ramlInfo.ErrorMessage);
return;
}
var model = new ClientGeneratorService(ramlInfo.RamlDocument, clientRootClassName, targetNamespace).BuildModel();
var directoryName = Path.GetDirectoryName(ramlDestFile).TrimEnd(Path.DirectorySeparatorChar);
var templateFolder = directoryName.Substring(0, directoryName.LastIndexOf(Path.DirectorySeparatorChar)) +
Path.DirectorySeparatorChar + "Templates";
var templateFilePath = Path.Combine(templateFolder, ClientT4TemplateName);
var extensionPath = Path.GetDirectoryName(GetType().Assembly.Location) + Path.DirectorySeparatorChar;
var t4Service = new T4Service(ServiceProvider);
var res = t4Service.TransformText(templateFilePath, model, extensionPath, ramlDestFile, targetNamespace);
if (res.HasErrors)
{
ActivityLog.LogError(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource, res.Errors);
MessageBox.Show(res.Errors);
return;
}
var content = TemplatesManager.AddClientMetadataHeader(res.Content);
var csTargetFile = Path.Combine(destFolderPath, destFolderName + ".cs");
File.WriteAllText(csTargetFile, content);
}
private static async Task <ClientGeneratorModel> GetRootGeneratedModel()
{
var raml = await new AmfParser().Load("files/root.raml");
var model = new ClientGeneratorService(raml, "Root", "TargetNamespace", "TargetNamespace.Models").BuildModel();
return(model);
}
public void Should_Build_Uri_Parameters_From_Resources()
{
var doc = new RamlDocument {
Title = "test"
};
var uriParameters = new Dictionary <string, Parameter>
{
{
"code", new Parameter
{
DisplayName = "code",
Type = "integer"
}
},
{
"token", new Parameter
{
DisplayName = "token",
Type = "string"
}
}
};
var methods = new List <Method>
{
new Method
{
Verb = "get"
}
};
var resources = new Collection <Resource>
{
new Resource
{
RelativeUri = "/movies/{token}/abc/{code}/asd/{extra}",
Methods = methods,
UriParameters = uriParameters
},
new Resource
{
RelativeUri = "/directors/{a}/abc/{b}{c}/asd/{d}",
Methods = methods
}
};
doc.Resources = resources;
var service = new ClientGeneratorService(doc, "test", "TestNs");
var model = service.BuildModel();
Assert.AreEqual(2, model.UriParameterObjects.Count);
var moviesUriParamObj = model.UriParameterObjects.First(o => o.Key.ToLowerInvariant().Contains("movies")).Value;
var directorsUriParamObj = model.UriParameterObjects.First(o => o.Key.ToLowerInvariant().Contains("directors")).Value;
Assert.AreEqual(3, moviesUriParamObj.Properties.Count);
Assert.AreEqual(4, directorsUriParamObj.Properties.Count);
}
public void should_build_uri_parameter_objects()
{
var doc = new RamlDocument {
Title = "test"
};
var uriParams = new Dictionary <string, Parameter>()
{
{
"code", new Parameter
{
DisplayName = "code",
Type = "integer"
}
},
{
"token", new Parameter
{
DisplayName = "token",
Type = "string"
}
}
};
var methods = new List <Method>
{
new Method
{
Verb = "get",
},
new Method
{
Verb = "post"
}
};
var resources = new Collection <Resource>
{
new Resource
{
RelativeUri = "/movies",
UriParameters = uriParams,
Methods = methods
}
};
doc.Resources = resources;
var service = new ClientGeneratorService(doc, "test", "NamespaceTest");
var model = service.BuildModel();
Assert.AreEqual(1, model.UriParameterObjects.Count);
Assert.AreEqual(2, model.UriParameterObjects.First().Value.Properties.Count);
Assert.IsTrue(model.Classes.First().Methods.All(m => m.UriParametersType == "MoviesUriParameters"));
Assert.AreEqual(1, model.Objects.Count());
}
private static async Task <ClientGeneratorModel> BuildModel(string ramlFile)
{
var fi = new FileInfo(ramlFile);
var raml = await new AmfParser().Load(fi.FullName);
var model = new ClientGeneratorService(raml, "test", "TargetNamespace", "TargetNamespace.Models").BuildModel();
return(model);
}
private async Task <ClientGeneratorModel> GetRegressionGeneratedModel()
{
var raml = await new RamlParser().LoadAsync("regression.raml");
var model = new ClientGeneratorService(raml, "test").BuildModel();
return(model);
}
[Test] // JSON.NET issue
public async Task ShouldHandleJsonSchemaRecursiveTree()
{
var raml = await new AmfParser().Load("files/tree-issue63.raml");
var model = new ClientGeneratorService(raml, "test", "TargetNamespace", "TargetNamespace.Models").BuildModel();
Assert.IsNotNull(model);
Assert.AreEqual(1, model.Objects.Count());
}
public void should_keep_original_names()
{
var doc = new RamlDocument {
Title = "test"
};
var uriParams = new Dictionary <string, Parameter>()
{
{
"code-oneOne", new Parameter
{
DisplayName = "code",
Type = "integer"
}
},
{
"token_Two", new Parameter
{
DisplayName = "token",
Type = "string"
}
}
};
var methods = new List <Method>
{
new Method
{
Verb = "get",
},
new Method
{
Verb = "post"
}
};
var resources = new Collection <Resource>
{
new Resource
{
RelativeUri = "/movies",
UriParameters = uriParams,
Methods = methods
}
};
doc.Resources = resources;
var service = new ClientGeneratorService(doc, "test", "TestNs");
var model = service.BuildModel();
Assert.AreEqual("code-oneOne", model.UriParameterObjects.First().Value.Properties.First(p => p.Name == "CodeoneOne").OriginalName);
Assert.AreEqual("token_Two", model.UriParameterObjects.First().Value.Properties.First(p => p.Name == "Token_Two").OriginalName);
}
private static ClientGeneratorModel GetGeneratorModel(string wszInputFilePath, RamlInfo ramlInfo)
{
var rootName = NetNamingMapper.GetObjectName(Path.GetFileNameWithoutExtension(wszInputFilePath));
if (!rootName.ToLower().Contains("api"))
{
rootName += "Api";
}
var model = new ClientGeneratorService(ramlInfo.RamlDocument, rootName).BuildModel();
return(model);
}
public void GenerateCode(RamlInfo data, string targetNamespace, string clientRootClassName, string ramlDestFile, string destFolderPath,
string destFolderName, ProjectItem ramlProjItem)
{
ThreadHelper.ThrowIfNotOnUIThread();
//var ramlInfo = await RamlInfoService.GetRamlInfo(ramlDestFile);
//if (ramlInfo.HasErrors)
//{
// ActivityLog.LogError(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource, ramlInfo.ErrorMessage);
// MessageBox.Show(ramlInfo.ErrorMessage);
// return;
//}
var model = new ClientGeneratorService(data.RamlDocument, clientRootClassName, targetNamespace, targetNamespace + ".Models").BuildModel();
var directoryName = Path.GetDirectoryName(ramlDestFile).TrimEnd(Path.DirectorySeparatorChar);
var templateFolder = directoryName.Substring(0, directoryName.LastIndexOf(Path.DirectorySeparatorChar)) +
Path.DirectorySeparatorChar + "Templates" + Path.DirectorySeparatorChar;
var templateFilePath = Path.Combine(templateFolder, ClientT4TemplateName);
var extensionPath = Path.GetDirectoryName(GetType().Assembly.Location) + Path.DirectorySeparatorChar;
// when array has no properties, set it collection on base type
foreach (var arrayModel in model.Objects.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
}
var t4Service = new T4Service(ServiceProvider);
var res = t4Service.TransformText(templateFilePath, model, extensionPath, ramlDestFile, targetNamespace);
if (res.HasErrors)
{
ActivityLog.LogError(VisualStudioAutomationHelper.RamlVsToolsActivityLogSource, res.Errors);
MessageBox.Show(res.Errors);
return;
}
var content = TemplatesManager.AddClientMetadataHeader(res.Content);
var csTargetFile = Path.Combine(destFolderPath, destFolderName + ".cs");
File.WriteAllText(csTargetFile, content);
ramlProjItem.ProjectItems.AddFromFile(csTargetFile);
}
public void Generate(AmfModel ramlDoc, string targetFileName, string targetNamespace, string templatesFolder,
string destinationFolder)
{
templatesFolder = string.IsNullOrWhiteSpace(templatesFolder)
? GetTemplateDefaultPath()
: templatesFolder;
var model = new ClientGeneratorService(ramlDoc, targetFileName + "Client", targetNamespace, targetNamespace + ".Models").BuildModel();
var templateFilePath = Path.Combine(templatesFolder, ClientT4TemplateName);
var extensionPath = Path.GetDirectoryName(GetType().Assembly.Location) + Path.DirectorySeparatorChar;
var host = new CustomCmdLineHost();
var engine = new Engine();
host.TemplateFileValue = templateFilePath;
// Read the T4 from disk into memory
var templateFileContent = File.ReadAllText(templateFilePath);
templateFileContent = templateFileContent.Replace("$(binDir)", extensionPath);
templateFileContent = templateFileContent.Replace("$(ramlFile)", targetFileName.Replace("\\", "\\\\"));
templateFileContent = templateFileContent.Replace("$(namespace)", targetNamespace);
host.Session = host.CreateSession();
host.Session["model"] = model;
var output = engine.ProcessTemplate(templateFileContent, host);
foreach (CompilerError error in host.Errors)
{
Console.WriteLine(error.ToString());
}
//var t4Service = new T4Service(ServiceProvider.GlobalProvider);
//var res = t4Service.TransformText(templateFilePath, model, extensionPath, opts.Source, targetNamespace);
File.WriteAllText(Path.Combine(destinationFolder, targetFileName.Replace(".raml", ".cs")), output, host.FileEncoding);
}
public void Should_Inherit_Uri_Parameters_When_Nested_Resources_ClientCase2()
{
var doc = new RamlDocument {
Title = "test"
};
var uriParameters1 = new Dictionary <string, Parameter>
{
{
"id", new Parameter
{
DisplayName = "id",
Type = "integer"
}
}
};
var uriParameters2 = new Dictionary <string, Parameter>
{
{
"current", new Parameter
{
DisplayName = "current",
Type = "boolean"
}
}
};
var methods = new List <Method>
{
new Method
{
Verb = "get"
}
};
var resources = new Collection <Resource>
{
new Resource
{
RelativeUri = "/{id}",
Methods = methods,
UriParameters = uriParameters1,
Resources = new Collection <Resource>
{
new Resource
{
RelativeUri = "/something",
Methods = methods,
Resources = new Collection <Resource>
{
new Resource
{
RelativeUri = "/{current}",
Methods = methods,
UriParameters = uriParameters2,
Resources = new Collection <Resource>
{
new Resource
{
RelativeUri = "/deep",
Methods = methods
}
}
}
}
}
}
}
};
doc.Resources = resources;
var service = new ClientGeneratorService(doc, "test", "TargetNamespace");
var model = service.BuildModel();
Assert.AreEqual("bool", model.Classes.First(m => m.Name.Contains("Deep")).Methods.First().UriParameters.First(p => p.Name == "current").Type);
Assert.AreEqual("int", model.Classes.First(m => m.Name.Contains("Deep")).Methods.First().UriParameters.First(p => p.Name == "id").Type);
}
public void Should_Build_Uri_Parameters_When_Nested_Resources()
{
var doc = new RamlDocument {
Title = "test"
};
var uriParameters = new Dictionary <string, Parameter>
{
{
"code", new Parameter
{
DisplayName = "code",
Type = "integer"
}
},
{
"token", new Parameter
{
DisplayName = "token",
Type = "string"
}
}
};
var methods = new List <Method>
{
new Method
{
Verb = "get"
}
};
var resources = new Collection <Resource>
{
new Resource
{
RelativeUri = "/movies/{token}{extra}/abc/{code}{extra}/asd",
Methods = methods,
UriParameters = uriParameters,
Resources = new[]
{
new Resource
{
RelativeUri = "/{a}{b}",
Methods = methods
}
}
}
};
doc.Resources = resources;
var service = new ClientGeneratorService(doc, "test", "TestNs");
var model = service.BuildModel();
Assert.AreEqual(2, model.UriParameterObjects.Count);
var moviesUriParamObj = model.UriParameterObjects.First().Value;
var directorsUriParamObj = model.UriParameterObjects.Last().Value;
Assert.AreEqual(3, moviesUriParamObj.Properties.Count);
Assert.AreEqual(5, directorsUriParamObj.Properties.Count);
}
public void Should_Build_Multiple_Headers_When_Many_Response_With_Headers()
{
var doc = new RamlDocument {
Title = "test"
};
var okHeaders = new Dictionary <string, Parameter>
{
{
"code",
new Parameter
{
DisplayName = "code",
Type = "integer"
}
},
{
"token",
new Parameter
{
DisplayName = "token",
Type = "string"
}
}
};
var errorHeaders = new Dictionary <string, Parameter>
{
{
"code",
new Parameter
{
DisplayName = "code",
Type = "integer"
}
},
{
"error",
new Parameter
{
DisplayName = "error",
Type = "string"
}
}
};
var badRequestHeaders = new Dictionary <string, Parameter>
{
{
"code",
new Parameter
{
DisplayName = "code",
Type = "integer"
}
},
{
"description",
new Parameter
{
DisplayName = "description",
Type = "string"
}
}
};
var okResponse = new Response
{
Code = "200",
Headers = okHeaders
};
var errorResponse = new Response
{
Code = "400",
Headers = errorHeaders
};
var notFoundResponse = new Response
{
Code = "404",
Headers = badRequestHeaders
};
var methods = new List <Method>
{
new Method
{
Verb = "get",
Responses = new[] { okResponse, errorResponse, notFoundResponse }
}
};
var resources = new Collection <Resource>
{
new Resource
{
RelativeUri = "movies",
Methods = methods
}
};
doc.Resources = resources;
var service = new ClientGeneratorService(doc, "test", "TargetNamespace");
var model = service.BuildModel();
Assert.AreEqual(4, model.ResponseHeaderObjects.Count);
var multipleModel = model.ResponseHeaderObjects.First(o => o.Key.Contains("Multiple")).Value;
Assert.AreEqual(3, multipleModel.Properties.Count);
Assert.AreEqual("Models." + model.ResponseHeaderObjects.First(o => o.Key.Contains("Multiple")).Value.Name,
model.Classes.First().Methods.First().ResponseHeaderType);
}
public void Should_Get_Multiple_Type_When_Many_Response_Schemas_On_Root()
{
var doc = new RamlDocument {
Title = "test"
};
var schemas = new List <Dictionary <string, string> >();
var schemaMovie = new Dictionary <string, string>();
schemaMovie.Add("movie", movieSchema);
var schemaError = new Dictionary <string, string>();
schemaMovie.Add("error", errorSchema);
var schemaNotFound = new Dictionary <string, string>();
schemaMovie.Add("notfound", notFoundSchema);
schemas.Add(schemaMovie);
schemas.Add(schemaError);
schemas.Add(schemaNotFound);
doc.Schemas = schemas;
var okResponse = new Response
{
Code = "200",
Body = new Dictionary <string, MimeType>
{
{
"application/json", new MimeType
{
Schema = "movie"
}
}
}
};
var errorResponse = new Response
{
Code = "400",
Body = new Dictionary <string, MimeType>
{
{
"application/json", new MimeType
{
Schema = "error"
}
}
}
};
var notFoundResponse = new Response
{
Code = "404",
Body = new Dictionary <string, MimeType>
{
{
"application/json", new MimeType
{
Schema = "notfound"
}
}
}
};
var methods = new List <Method>
{
new Method
{
Verb = "get",
Responses = new[] { okResponse, errorResponse, notFoundResponse }
}
};
var resources = new Collection <Resource>
{
new Resource
{
RelativeUri = "movies",
Methods = methods
}
};
doc.Resources = resources;
var service = new ClientGeneratorService(doc, "test");
var model = service.BuildModel();
Assert.AreEqual(4, model.ResponseObjects.Count);
var multipleModel = model.ResponseObjects.First(o => o.Key.Contains("Multiple")).Value;
Assert.AreEqual(3, multipleModel.Properties.Count);
Assert.AreEqual(1, multipleModel.Properties.Count(p => p.Type == "Movie"));
Assert.AreEqual(1, multipleModel.Properties.Count(p => p.Type == "Error"));
Assert.AreEqual(1, multipleModel.Properties.Count(p => p.Type == "Notfound"));
}
public void Should_Get_Multiple_Type_When_Many_Response_Schemas_On_Resource()
{
var doc = new RamlDocument { Title = "test" };
var okResponse = new Response
{
Code = "200",
Body = new Dictionary<string, MimeType>
{
{
"application/json", new MimeType
{
Schema = movieSchema
}
}
}
};
var errorResponse = new Response
{
Code = "400",
Body = new Dictionary<string, MimeType>
{
{
"application/json", new MimeType
{
Schema = errorSchema
}
}
}
};
var notFoundResponse = new Response
{
Code = "404",
Body = new Dictionary<string, MimeType>
{
{
"application/json", new MimeType
{
Schema = notFoundSchema
}
}
}
};
var methods = new List<Method>
{
new Method
{
Verb = "get",
Responses = new[] { okResponse, errorResponse, notFoundResponse }
}
};
var resources = new Collection<Resource>
{
new Resource
{
RelativeUri = "/movies",
Methods = methods
}
};
doc.Resources = resources;
var service = new ClientGeneratorService(doc, "test", "TestNs");
var model = service.BuildModel();
Assert.AreEqual(4, model.ResponseObjects.Count);
var multipleModel = model.ResponseObjects.First(o => o.Key.Contains("Multiple")).Value;
Assert.AreEqual(3, multipleModel.Properties.Count);
}
private static ClientGeneratorModel GetGeneratorModel(string clientRootClassName, RamlInfo ramlInfo, string targetNamespace)
{
var model = new ClientGeneratorService(ramlInfo.RamlDocument, clientRootClassName, targetNamespace).BuildModel();
return(model);
}
