public async Task When_generic_request()
{
//// Arrange
var generator = new WebApiToSwaggerGenerator(new WebApiToSwaggerGeneratorSettings());
var document = await generator.GenerateForControllerAsync <DiscussionController>();
var json = document.ToJson();
//// Act
var codeGen = new SwaggerToTypeScriptClientGenerator(document, new SwaggerToTypeScriptClientGeneratorSettings
{
Template = TypeScriptTemplate.Angular,
GenerateDtoTypes = true,
TypeScriptGeneratorSettings =
{
TypeScriptVersion = 2.7m,
ExportTypes = false
}
});
var code = codeGen.GenerateFile();
//// Assert
Assert.Contains("this.request = new RequestBodyBase()", code);
Assert.Contains("this.request = new RequestBody()", code);
}
static void Main(string[] args)
{
var currentFolder = Directory.GetCurrentDirectory();
var pathToDll = Path.Combine(currentFolder, "..", "ContactsList/bin/Debug/netcoreapp1.1/AspNetCoreSpa.dll");
var settings = new WebApiAssemblyToSwaggerGeneratorSettings
{
AssemblyPaths = new string[] { pathToDll },
DefaultUrlTemplate = "api/{controller}/{action}/{id}",
DefaultPropertyNameHandling = NJsonSchema.PropertyNameHandling.CamelCase
};
//var excluded = new string[] { "Manage", "Base", "Home" };
var generator = new WebApiAssemblyToSwaggerGenerator(settings);
var allClasses = generator.GetControllerClasses();
//var necessaryClasses = allClasses.Except(allClasses.Where(x => excluded.Any(y => x.Contains(y)))
// ).ToArray();
var controllersToGenerate = new string[] { "File" };
var necessaryClasses = allClasses.Where(x => controllersToGenerate.Any(y => x.Contains(y)))
.ToArray();
var document = generator.GenerateForControllersAsync(necessaryClasses).Result;
var settingsForClientApiGeneration = new SwaggerToTypeScriptClientGeneratorSettings
{
ClassName = "{controller}Client",
Template = TypeScriptTemplate.Angular
};
var generatorApi = new SwaggerToTypeScriptClientGenerator(document, settingsForClientApiGeneration);
var code = generatorApi.GenerateFile();
code = ImproveGeneration(code);
File.WriteAllText(Path.Combine(currentFolder, "..", "ContactsList/Client/app", "apiDefinitions.ts"), code);
}
public static void UseGeneratedClient(this IApplicationBuilder app, string url)
{
Task.Run(() => {
Thread.Sleep(2000);
SwaggerDocument document = null;
int attemptCount = 0;
while (document == null && attemptCount < 5)
{
attemptCount++;
System.Console.WriteLine("Attempting to load swagger specification for client generation.");
try {
document = SwaggerDocument.FromUrlAsync(url).Result;
} catch {
System.Console.WriteLine("Failed to load swagger specification. Retry in 2 seconds.");
Thread.Sleep(2000);
}
}
var settings = new SwaggerToTypeScriptClientGeneratorSettings {
Template = TypeScriptTemplate.Angular,
ClassName = "{controller}Client",
InjectionTokenType = InjectionTokenType.InjectionToken
};
var generator = new SwaggerToTypeScriptClientGenerator(document, settings);
var code = generator.GenerateFile();
System.Console.WriteLine(code);
System.IO.File.WriteAllText(@"./ClientApp/src/app/app.service.ts", code);
});
}
public async Task When_operations_have_no_tags_they_are_grouped_into_one_client()
{
//// Arrange
var generator = new WebApiToSwaggerGenerator(new WebApiToSwaggerGeneratorSettings());
var document = await generator.GenerateForControllersAsync(new List <Type>() { typeof(PointControllerA), typeof(PointControllerB) });
// Remove tags
foreach (var path in document.Paths.Values)
{
foreach (var operation in path.Values)
{
operation.Tags.Clear();
}
}
var codeGenerator = new SwaggerToTypeScriptClientGenerator(document, new SwaggerToTypeScriptClientGeneratorSettings
{
OperationNameGenerator = new MultipleClientsFromFirstTagAndPathSegmentsOperationNameGenerator()
});
//// Act
var code = codeGenerator.GenerateFile();
//// Assert
Assert.IsTrue(code.Contains("export class Client"));
Assert.IsTrue(!code.Contains("export class PointControllerAClient"));
Assert.IsTrue(!code.Contains("export class PointControllerBClient"));
}
public async Task When_query_parameter_is_enum_array_then_the_enum_is_referenced()
{
//// Arrange
var settings = new WebApiToSwaggerGeneratorSettings
{
DefaultUrlTemplate = "api/{controller}/{action}/{id}",
DefaultEnumHandling = EnumHandling.String,
DefaultPropertyNameHandling = PropertyNameHandling.Default,
SchemaType = SchemaType.Swagger2,
};
var generator = new WebApiToSwaggerGenerator(settings);
//// Act
var document = await generator.GenerateForControllerAsync <FooController>();
var json = document.ToJson();
var gen = new SwaggerToTypeScriptClientGenerator(document, new SwaggerToTypeScriptClientGeneratorSettings
{
Template = TypeScriptTemplate.JQueryCallbacks
});
var code = gen.GenerateFile();
//// Assert
Assert.IsNotNull(document.Operations.First().Operation.Parameters.First().Item.SchemaReference);
Assert.IsTrue(code.Contains("getFoos(bars: Bar[], "));
}
/// <summary>Initializes a new instance of the <see cref="TypeScriptOperationModel" /> class.</summary>
/// <param name="operation">The operation.</param>
/// <param name="settings">The settings.</param>
/// <param name="generator">The generator.</param>
/// <param name="resolver">The resolver.</param>
public TypeScriptOperationModel(
SwaggerOperation operation,
SwaggerToTypeScriptClientGeneratorSettings settings,
SwaggerToTypeScriptClientGenerator generator,
TypeResolverBase resolver)
: base(null, operation, resolver, generator, settings)
{
_operation = operation;
_settings = settings;
_generator = generator;
var parameters = GetActualParameters();
if (settings.GenerateOptionalParameters)
{
parameters = parameters
.OrderBy(p => p.Position ?? 0)
.OrderBy(p => !p.IsRequired)
.ToList();
}
Parameters = parameters
.Select(parameter =>
new TypeScriptParameterModel(parameter.Name,
GetParameterVariableName(parameter, _operation.Parameters), ResolveParameterType(parameter),
parameter, parameters, _settings, _generator, resolver))
.ToList();
}
public static void GenerateTS(SwaggerDocument document, ApiClientDefinition definition)
{
var settings = new SwaggerToTypeScriptClientGeneratorSettings()
{
Template = TypeScriptTemplate.Fetch,
OperationNameGenerator = new CustomNameGenerator(),
GenerateOptionalParameters = true,
UseTransformOptionsMethod = true,
ClientBaseClass = "ClientBase"
};
settings.TypeScriptGeneratorSettings.PropertyNameGenerator = new MyPropertyNameGenerator(c => ConversionUtilities.ConvertToLowerCamelCase(c, true));
settings.TypeScriptGeneratorSettings.NullValue = TypeScriptNullValue.Null;
var generator = new SwaggerToTypeScriptClientGenerator(document, settings);
var ts = generator.GenerateFile();
var baseClass = CreateBaseClass(definition);
ts = WrapInNamespace(definition, ts, baseClass);
File.WriteAllText(definition.TypescriptClient, ts);
if (definition.CompileTypescript)
{
Process.Start("tsc", definition.TypescriptClient).WaitForExit();
}
}
public async Task When_export_types_is_false_then_dont_add_export_before_classes()
{
//// Arrange
var generator = new WebApiToSwaggerGenerator(new WebApiToSwaggerGeneratorSettings());
var document = await generator.GenerateForControllerAsync <DiscussionController>();
var json = document.ToJson();
//// Act
var codeGen = new SwaggerToTypeScriptClientGenerator(document, new SwaggerToTypeScriptClientGeneratorSettings
{
Template = TypeScriptTemplate.JQueryPromises,
GenerateClientInterfaces = true,
TypeScriptGeneratorSettings =
{
TypeScriptVersion = 2.0m,
ExportTypes = false
}
});
var code = codeGen.GenerateFile();
//// Assert
Assert.IsFalse(code.Contains("export class DiscussionClient"));
Assert.IsFalse(code.Contains("export interface IDiscussionClient"));
}
/// <summary>Initializes a new instance of the <see cref="TypeScriptParameterModel" /> class.</summary>
/// <param name="parameterName">Name of the parameter.</param>
/// <param name="variableName">Name of the variable.</param>
/// <param name="typeName">The type name.</param>
/// <param name="parameter">The parameter.</param>
/// <param name="allParameters">All parameters.</param>
/// <param name="settings">The settings.</param>
/// <param name="generator">The client generator base.</param>
/// <param name="resolver">The resolver.</param>
public TypeScriptParameterModel(string parameterName, string variableName, string typeName, SwaggerParameter parameter,
IList <SwaggerParameter> allParameters, SwaggerToTypeScriptClientGeneratorSettings settings,
SwaggerToTypeScriptClientGenerator generator, TypeScriptTypeResolver resolver)
: base(parameterName, variableName, typeName, parameter, allParameters, settings.TypeScriptGeneratorSettings, generator)
{
_settings = settings;
_resolver = resolver;
}
static void GenerateFile(SwaggerDocument document, SwaggerToTypeScriptClientGeneratorSettings settings, string clientFile)
{
var generator = new SwaggerToTypeScriptClientGenerator(document, settings);
var code = generator.GenerateFile();
using (var writer = new StreamWriter(clientFile, false, Encoding.UTF8))
{
writer.Write(code);
}
}
public IActionResult Generate()
{
var settings = new WebApiToSwaggerGeneratorSettings
{
DefaultUrlTemplate = "api/{controller}/{action}/{id}",
DefaultPropertyNameHandling = PropertyNameHandling.CamelCase
};
var generator = new WebApiToSwaggerGenerator(settings);
var controllers = typeof(Ng2GenerateController).GetTypeInfo().Assembly.GetTypes()
.Where(t => typeof(Controller).IsAssignableFrom(t))
.ToList();
var document = generator.GenerateForControllers(controllers);
//var json = document.ToJson();
//return Content(document.ToJson());
var typescriptGeneratorSettings = new SwaggerToTypeScriptClientGeneratorSettings()
{
ClassName = "{controller}Client",
Template = TypeScriptTemplate.Angular2,
GenerateClientClasses = true,
GenerateClientInterfaces = true,
GenerateDtoTypes = true,
TypeScriptGeneratorSettings = new TypeScriptGeneratorSettings()
{
TypeStyle = TypeScriptTypeStyle.Interface,
//TypeNameGenerator = new MyTypeNameGenerator(),
}
};
var tsGenerator = new SwaggerToTypeScriptClientGenerator(document, typescriptGeneratorSettings);
var typescript = tsGenerator.GenerateFile();
typescript = @"
// this is file generated by hitting the /swagger/ng2 endpoint
" + typescript;
// hack!
typescript = typescript.Replace("return <Observable<any>><any>Observable.throw(e);",
"return <Observable<any>><any>Observable.throw(response);");
typescript = typescript.Replace("return <Observable<UserProfileVm>><any>Observable.throw(e)",
"return <Observable<any>><any>Observable.throw(response)");
// write typescript to file under ng app
var webRoot = _env.WebRootPath;
var file = System.IO.Path.Combine(webRoot, @"..\ClientApp\app\Right4MeClient.ts");
System.IO.File.WriteAllText(file, typescript);
return(Content(typescript));
}
public async Task GenerateTS()
{
var document = await GetSwaggerDocument();
var settings = new SwaggerToTypeScriptClientGeneratorSettings()
{
Template = TypeScriptTemplate.Fetch
};
var generator = new SwaggerToTypeScriptClientGenerator(document, settings);
File.WriteAllText(TSPath, generator.GenerateFile());
}
public async Task <string> RunAsync()
{
var additionalCode = ExtensionCode ?? string.Empty;
if (File.Exists(additionalCode))
{
additionalCode = File.ReadAllText(additionalCode);
}
Settings.TypeScriptGeneratorSettings.ExtensionCode = additionalCode;
var clientGenerator = new SwaggerToTypeScriptClientGenerator(InputSwaggerService, Settings);
return(clientGenerator.GenerateFile());
}
public async Task GenerateTS()
{
var document = await GetSwaggerDocument();
var settings = new SwaggerToTypeScriptClientGeneratorSettings()
{
Template = TypeScriptTemplate.Fetch,
};
var generator = new SwaggerToTypeScriptClientGenerator(document, settings);
Context.ReturnFile(Encoding.UTF8.GetBytes(generator.GenerateFile().Replace("\nexport ", "\n")), "ApiClient.ts", "text/plain");
//File.WriteAllText(TSPath, generator.GenerateFile());
}
public async Task When_body_is_binary_then_blob_is_used_as_parameter_in_TypeScript()
{
var yaml = @"openapi: 3.0.0
servers:
- url: https://www.example.com/
info:
version: '2.0.0'
title: 'Test API'
paths:
/files:
post:
tags:
- Files
summary: 'Add File'
operationId: addFile
responses:
'200':
content:
application/xml:
schema:
$ref: '#/components/schemas/FileToken'
requestBody:
content:
image/png:
schema:
type: string
format: binary
components:
schemas:
FileToken:
type: object
required:
- fileId
properties:
fileId:
type: string
format: uuid";
var document = await SwaggerYamlDocument.FromYamlAsync(yaml);
//// Act
var codeGenerator = new SwaggerToTypeScriptClientGenerator(document, new SwaggerToTypeScriptClientGeneratorSettings());
var code = codeGenerator.GenerateFile();
//// Assert
Assert.Contains("addFile(body: Blob | undefined): ", code);
Assert.Contains("\"Content-Type\": \"image/png\"", code);
Assert.Contains("\"Accept\": \"application/xml\"", code);
Assert.Contains("const content_ = body;", code);
}
public async Task <string> RunAsync()
{
return(await Task.Run(() =>
{
var additionalCode = ExtensionCode ?? string.Empty;
if (DynamicApis.FileExists(additionalCode))
{
additionalCode = DynamicApis.FileReadAllText(additionalCode);
}
Settings.TypeScriptGeneratorSettings.ExtensionCode = additionalCode;
var clientGenerator = new SwaggerToTypeScriptClientGenerator(InputSwaggerDocument, Settings);
return clientGenerator.GenerateFile();
}));
}
public async Task <string> RunAsync()
{
return(await Task.Run(async() =>
{
var additionalCode = ExtensionCode ?? string.Empty;
if (await DynamicApis.FileExistsAsync(additionalCode).ConfigureAwait(false))
{
additionalCode = await DynamicApis.FileReadAllTextAsync(additionalCode).ConfigureAwait(false);
}
Settings.TypeScriptGeneratorSettings.ExtensionCode = additionalCode;
var document = await GetInputSwaggerDocument().ConfigureAwait(false);
var clientGenerator = new SwaggerToTypeScriptClientGenerator(document, Settings);
return clientGenerator.GenerateFile();
}));
}
public string Gen(SwaggerDocument service, SwaggerToolSettings setting, TypeScriptTemplate Template)
{
var settings = new SwaggerToTypeScriptClientGeneratorSettings
{
ClassName = setting.TypeScriptGen.ClassName,
Template = Template,
PromiseType = PromiseType.Promise,
TypeScriptGeneratorSettings = { ModuleName = setting.TypeScriptGen.ModuleName }
};
var generator = new SwaggerToTypeScriptClientGenerator(service, settings);
var code = generator.GenerateFile();
return(code);
}
public async Task When_body_is_xml_then_correct_TypeScript_is_generated()
{
//// Arrange
var generator = new WebApiToSwaggerGenerator(new WebApiToSwaggerGeneratorSettings());
var document = await generator.GenerateForControllerAsync <MyXmlController>();
//// Act
var gen = new SwaggerToTypeScriptClientGenerator(document, new SwaggerToTypeScriptClientGeneratorSettings {
Template = TypeScriptTemplate.JQueryCallbacks
});
var code = gen.GenerateFile();
//// Assert
Assert.IsTrue(code.Contains("(xmlDocument: string, "));
Assert.IsTrue(code.Contains("const content_ = xmlDocument;"));
Assert.IsTrue(code.Contains("\"Content-Type\": \"application/xml; charset=UTF-8\""));
}
public void When_two_methods_have_same_name_then_generated_id_is_still_different()
{
//// Arrange
var generator = new SwaggerGenerators.WebApi.WebApiToSwaggerGenerator(new WebApiToSwaggerGeneratorSettings());
var service = generator.GenerateForController <PointController>();
var codeGenerator = new SwaggerToTypeScriptClientGenerator(service, new SwaggerToTypeScriptClientGeneratorSettings
{
OperationGenerationMode = OperationGenerationMode.MultipleClientsFromOperationId
});
//// Act
var code = codeGenerator.GenerateFile();
//// Assert
Assert.IsTrue(code.Contains(" get("));
Assert.IsTrue(code.Contains(" get2("));
}
public void When_generating_TypeScript_code_then_output_contains_expected_classes()
{
// Arrange
var service = CreateService();
//// Act
var generator = new SwaggerToTypeScriptClientGenerator(service, new SwaggerToTypeScriptClientGeneratorSettings
{
ClassName = "MyClass"
});
var code = generator.GenerateFile();
// Assert
Assert.IsTrue(code.Contains("export class MyClass"));
Assert.IsTrue(code.Contains("export interface Person"));
Assert.IsTrue(code.Contains("export interface Address"));
}
/// <summary>Initializes a new instance of the <see cref="TypeScriptOperationModel" /> class.</summary>
/// <param name="operation">The operation.</param>
/// <param name="settings">The settings.</param>
/// <param name="generator">The generator.</param>
/// <param name="resolver">The resolver.</param>
public TypeScriptOperationModel(
SwaggerOperation operation,
ClientGeneratorBaseSettings settings,
SwaggerToTypeScriptClientGenerator generator,
ITypeResolver resolver)
: base(null, operation, resolver, generator, settings)
{
_operation = operation;
_settings = settings;
_generator = generator;
Parameters = _operation.ActualParameters.Select(parameter =>
new TypeScriptParameterModel(parameter.Name,
GetParameterVariableName(parameter, _operation.Parameters), ResolveParameterType(parameter),
parameter, _operation.ActualParameters.ToList(), (SwaggerToTypeScriptClientGeneratorSettings)_settings,
_generator, (TypeScriptTypeResolver)resolver))
.ToList();
}
public async Task When_two_methods_have_same_name_then_generated_id_is_still_different()
{
//// Arrange
var generator = new WebApiToSwaggerGenerator(new WebApiToSwaggerGeneratorSettings());
var document = await generator.GenerateForControllerAsync <PointController>();
var codeGenerator = new SwaggerToTypeScriptClientGenerator(document, new SwaggerToTypeScriptClientGeneratorSettings
{
OperationNameGenerator = new MultipleClientsFromOperationIdOperationNameGenerator()
});
//// Act
var code = codeGenerator.GenerateFile();
//// Assert
Assert.IsTrue(code.Contains(" get("));
Assert.IsTrue(code.Contains(" getAll("));
}
public async Task When_operations_have_different_tags_they_are_grouped_into_different_clients()
{
//// Arrange
var generator = new WebApiToSwaggerGenerator(new WebApiToSwaggerGeneratorSettings());
var document = await generator.GenerateForControllersAsync(new List <Type>() { typeof(PointControllerA), typeof(PointControllerB) });
var codeGenerator = new SwaggerToTypeScriptClientGenerator(document, new SwaggerToTypeScriptClientGeneratorSettings
{
OperationNameGenerator = new MultipleClientsFromFirstTagAndPathSegmentsOperationNameGenerator()
});
//// Act
var code = codeGenerator.GenerateFile();
//// Assert
Assert.IsTrue(code.Contains("export class PointControllerAClient"));
Assert.IsTrue(code.Contains("export class PointControllerBClient"));
}
async Task <string> GetSwaggerWay2()
{
var document = new SwaggerDocument();
var Settings = new JsonSchemaGeneratorSettings()
{
SchemaType = SchemaType.Swagger2,
};
var generator = new JsonSchemaGenerator(Settings);
var schemaResolver = new SwaggerSchemaResolver(document, Settings);
var loadedAssemblies = LoadDtoAssemblies();
foreach (var dtoAsm in loadedAssemblies.Dto)
{
var models = dtoAsm.Assembly.GetTypes()
.Where(x => x.Namespace.StartsWith(dtoAsm.ProjectName + ".Public"));
foreach (var model in models)
{
await generator.GenerateAsync(model, schemaResolver).ConfigureAwait(false);
}
/*
* //this swagger.json will be wrong (paths and controller is not detected)
* var controllers = dtoAsm.Assembly.GetTypes()
* .Where(x => x.Name.EndsWith("Controller"));
*
* foreach (var controller in controllers)
* {
* await generator.GenerateAsync(controller, schemaResolver).ConfigureAwait(false);
* }
*/
}
//File.WriteAllText(Path.Combine(outputPath, "swagger.json"), document.ToJson());
var tsGenerator = new SwaggerToTypeScriptClientGenerator(document,
new SwaggerToTypeScriptClientGeneratorSettings
{
ClassName = "{controller}Client",
});
var tsModels = tsGenerator.GenerateFile();
return(tsModels);
}
static void Main(string[] args)
{
var document = SwaggerDocument.FromFileAsync("./swagger-doc.json").Result;
var settings = new SwaggerToTypeScriptClientGeneratorSettings
{
TypeScriptGeneratorSettings =
{
TypeScriptVersion = 2.3m,
TypeStyle = TypeScriptTypeStyle.Class,
NullHandling = NullHandling.Swagger
},
Template = TypeScriptTemplate.Angular
};
var generator = new SwaggerToTypeScriptClientGenerator(document, settings);
Console.WriteLine(generator.GenerateFile());
}
// First arg indicates what file we should save the generated code to.
static void Main(string[] args)
{
if (args.Length != 1)
{
throw new Exception("Expected exactly one argument, which is the target file name of the generated TS code.");
}
var settings = new SwaggerToTypeScriptClientGeneratorSettings
{
ClassName = "SD2{controller}Api",
GenerateClientInterfaces = true,
Template = TypeScriptTemplate.Angular
};
var swaggerDoc = Swagger.GenerateSwaggerDocument().Result;
var generator = new SwaggerToTypeScriptClientGenerator(swaggerDoc, settings);
var typescriptCode = generator.GenerateFile();
File.WriteAllText(args[0], typescriptCode);
}
public async Task GenerateTS()
{
var document = await GetSwaggerDocument();
var settings = new SwaggerToTypeScriptClientGeneratorSettings()
{
Template = TypeScriptTemplate.Fetch,
OperationNameGenerator = new CustomNameGenerator()
};
settings.TypeScriptGeneratorSettings.PropertyNameGenerator = new MyPropertyNameGenerator(c => ConversionUtilities.ConvertToLowerCamelCase(c, true));
settings.TypeScriptGeneratorSettings.NullValue = NJsonSchema.CodeGeneration.TypeScript.TypeScriptNullValue.Null;
var generator = new SwaggerToTypeScriptClientGenerator(document, settings);
var ts = generator.GenerateFile();
ts = "namespace " + Namespace + " {\n" + ConversionUtilities.Tab(ts, 1).TrimEnd('\n') + "\n}\n";
Context.ReturnFile(Encoding.UTF8.GetBytes(ts), "ApiClient.ts", "text/plain");
//File.WriteAllText(TSPath, generator.GenerateFile());
}
public async Task When_return_value_is_void_then_client_returns_observable_of_void()
{
//// Arrange
var generator = new WebApiToSwaggerGenerator(new WebApiToSwaggerGeneratorSettings());
var document = await generator.GenerateForControllerAsync<DiscussionController>();
//// Act
var codeGen = new SwaggerToTypeScriptClientGenerator(document, new SwaggerToTypeScriptClientGeneratorSettings
{
Template = TypeScriptTemplate.Angular,
GenerateClientInterfaces = true,
TypeScriptGeneratorSettings =
{
TypeScriptVersion = 2.0m
}
});
var code = codeGen.GenerateFile();
//// Assert
Assert.IsTrue(code.Contains("addMessage(message: Foo): Observable<void>"));
}
public async Task When_generating_TypeScript_code_then_output_contains_expected_classes()
{
// Arrange
var document = await CreateDocumentAsync();
//// Act
var generator = new SwaggerToTypeScriptClientGenerator(document, new SwaggerToTypeScriptClientGeneratorSettings
{
ClassName = "MyClass",
TypeScriptGeneratorSettings =
{
TypeStyle = TypeScriptTypeStyle.Interface
}
});
var code = generator.GenerateFile();
// Assert
Assert.IsTrue(code.Contains("export class MyClass"));
Assert.IsTrue(code.Contains("export interface Person"));
Assert.IsTrue(code.Contains("export interface Address"));
}
