private async Task GenerateAsync(string type)
{
IsLoading = true;
await RunTaskAsync(async() =>
{
if (type == "files")
{
await Document.Document.ExecuteAsync();
}
else
{
var generator = Document.GetSwaggerGeneratorView();
var swaggerCode = await generator.GenerateSwaggerAsync();
if (!string.IsNullOrEmpty(swaggerCode))
{
var document = await SwaggerDocument.FromJsonAsync(swaggerCode);
var documentPath = Document.GetDocumentPath(generator);
foreach (var codeGenerator in Document.CodeGenerators)
{
await codeGenerator.GenerateClientAsync(document, documentPath);
}
}
else
{
MessageBox.Show("No Swagger specification", "Could not generate code because the Swagger generator returned an empty document.");
}
}
});
IsLoading = false;
}
/// <summary>Generates the Swagger definition for all controllers in the assembly.</summary>
/// <param name="controllerClassNames">The controller class names.</param>
/// <exception cref="InvalidOperationException">No assembly paths have been provided.</exception>
/// <returns>The Swagger definition.</returns>
public override async Task <SwaggerDocument> GenerateForControllersAsync(IEnumerable <string> controllerClassNames)
{
if (!(Settings.SchemaNameGenerator is DefaultSchemaNameGenerator))
{
throw new InvalidOperationException("The SchemaNameGenerator cannot be customized when loading types from external assemblies.");
}
if (!(Settings.TypeNameGenerator is DefaultTypeNameGenerator))
{
throw new InvalidOperationException("The TypeNameGenerator cannot be customized when loading types from external assemblies.");
}
#if FullNet
using (var isolated = new AppDomainIsolation <WebApiAssemblyLoader>(Path.GetDirectoryName(Path.GetFullPath(Settings.AssemblyPaths.First())), Settings.AssemblyConfig))
{
var document = await Task.Run(() => isolated.Object.GenerateForControllers(controllerClassNames, JsonConvert.SerializeObject(Settings))).ConfigureAwait(false);
return(await SwaggerDocument.FromJsonAsync(document).ConfigureAwait(false));
}
#else
var loader = new WebApiAssemblyLoader();
var data = loader.GenerateForControllers(controllerClassNames, JsonConvert.SerializeObject(Settings));
return(await SwaggerDocument.FromJsonAsync(data).ConfigureAwait(false));
#endif
}
//[TestMethod]
public async Task RunIntegrationTests()
{
//// Arrange
foreach (var path in Directory.GetDirectories("../../../NSwag.Integration.Tests"))
{
try
{
var configPath = Path.GetFullPath(path + "/nswag.json");
var config = await NSwagDocument.LoadAsync(configPath);
var outputPath = config.SwaggerGenerators.WebApiToSwaggerCommand.OutputFilePath;
//// Act
var command = "run \"" + configPath + "\"";
var output = RunCommandLine(command, outputPath);
var document = await SwaggerDocument.FromJsonAsync(output);
//// Assert
Assert.IsTrue(document.Paths.Any());
Debug.WriteLine("The integration test '" + Path.GetFileName(path) + "' passed!");
}
catch (Exception e)
{
throw new Exception("The integration test '" + Path.GetFileName(path) + "' failed: " + e);
}
}
}
private async Task <SwaggerDocument> CreateDocumentAsync(WebApiToSwaggerGeneratorSettings settings)
{
var document = !string.IsNullOrEmpty(settings.DocumentTemplate) ?
await SwaggerDocument.FromJsonAsync(settings.DocumentTemplate).ConfigureAwait(false) :
new SwaggerDocument();
document.Generator = "NSwag v" + SwaggerDocument.ToolchainVersion + " (NJsonSchema v" + JsonSchema4.ToolchainVersion + ")";
document.Consumes = new List <string> {
"application/json"
};
document.Produces = new List <string> {
"application/json"
};
if (document.Info == null)
{
document.Info = new SwaggerInfo();
}
if (!string.IsNullOrEmpty(settings.Title))
{
document.Info.Title = settings.Title;
}
if (!string.IsNullOrEmpty(settings.Description))
{
document.Info.Description = settings.Description;
}
if (!string.IsNullOrEmpty(settings.Version))
{
document.Info.Version = settings.Version;
}
return(document);
}
public async Task When_request_body_is_changed_then_body_parameter_Content_is_updated()
{
//// Arrange
var document = CreateDocument();
//// Act
var json = document.ToJson(SchemaType.OpenApi3);
document = await SwaggerDocument.FromJsonAsync(json);
var requestBody = document.Paths["/baz"][SwaggerOperationMethod.Get].RequestBody;
requestBody.Content["application/json"] = new OpenApiMediaType
{
Schema = new JsonSchema4 {
Title = "blub"
}
};
//// Assert
var parameter = document.Paths["/baz"][SwaggerOperationMethod.Get].Parameters
.Single(p => p.Kind == SwaggerParameterKind.Body);
Assert.Equal("blub", parameter.Schema.Title);
}
private async Task <SwaggerDocument> CreateDocumentAsync()
{
var document = !string.IsNullOrEmpty(Settings.DocumentTemplate) ?
await SwaggerDocument.FromJsonAsync(Settings.DocumentTemplate).ConfigureAwait(false) :
new SwaggerDocument();
document.Generator = $"NSwag v{SwaggerDocument.ToolchainVersion} (NJsonSchema v{JsonSchema4.ToolchainVersion})";
document.SchemaType = Settings.SchemaType;
if (document.Info == null)
{
document.Info = new SwaggerInfo();
}
if (string.IsNullOrEmpty(Settings.DocumentTemplate))
{
if (!string.IsNullOrEmpty(Settings.Title))
{
document.Info.Title = Settings.Title;
}
if (!string.IsNullOrEmpty(Settings.Description))
{
document.Info.Description = Settings.Description;
}
if (!string.IsNullOrEmpty(Settings.Version))
{
document.Info.Version = Settings.Version;
}
}
return(document);
}
public async Task GenerateAsync()
{
//var httpClient = new System.Net.Http.HttpClient();
//string content = await httpClient.GetStringAsync("https://qa.trunovate.com/entitymanager/swagger/1.1.0.0/swagger.json");
string content = File.ReadAllText(Swagger);
var dir = Path.GetFullPath(Output);
var fileSink = new FileSink(dir);
var document = await SwaggerDocument.FromJsonAsync(content);
var settings = new SwaggerToCSharpClientGeneratorSettings
{
CSharpGeneratorSettings =
{
TemplateFactory = new SwaggerTemplateFactory(document, fileSink, Subsystem, ServiceName)
}
};
var generator = new SwaggerToCSharpClientGenerator(document, settings);
_ = generator.GenerateFile();
Console.WriteLine(dir);
}
private static async Task <SwaggerDocument> GetSwaggerDocument(string url)
{
var webClient = new WebClient();
var json = await webClient.DownloadStringTaskAsync(url);
var document = await SwaggerDocument.FromJsonAsync(json);
return(document);
}
public MockSwaggerServer(string spec)
{
var document = SwaggerDocument.FromJsonAsync(spec).Result;
var webhost = new WebHostBuilder()
.ConfigureServices(services => services.AddSingleton(document))
.UseStartup <Startup>();
_server = new TestServer(webhost);
}
public override async Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host)
{
var documentJson = await RunIsolatedAsync((string)null);
var document = await SwaggerDocument.FromJsonAsync(documentJson, expectedSchemaType : OutputType).ConfigureAwait(false);
await this.TryWriteDocumentOutputAsync(host, () => document).ConfigureAwait(false);
return(document);
}
public async Task When_document_has_null_schema_definition_then_it_is_ignored()
{
//// Arrange
var json = @"{ ""definitions"": { ""definitions"": null } }";
//// Act
var document = await SwaggerDocument.FromJsonAsync(json);
//// Assert
Assert.True(document.Definitions.Count == 0);
}
public async Task When_json_has_extension_data_then_it_is_loaded()
{
//// Arrange
var json = _jsonVendorExtensionData;
//// Act
var document = await SwaggerDocument.FromJsonAsync(json);
//// Assert
Assert.NotNull(document.Operations.First().Operation.ActualResponses["202"].ExtensionData);
}
public async Task ExtensionDataTest()
{
//// Arrange
var json = _jsonVendorExtensionData;
//// Act
var document = await SwaggerDocument.FromJsonAsync(json);
//// Assert
Assert.IsNotNull(document.Operations.First().Operation.Responses["202"].ExtensionData);
}
public async Task When_config_file_with_project_with_newer_json_net_is_run_then_property_is_correct()
{
//// Arrange
var command = "run \"" + Path.GetFullPath("../../../NSwag.VersionMissmatchTest/nswag.json") + "\"";
//// Act
var output = RunCommandLine(command, Path.GetFullPath("../../../NSwag.VersionMissmatchTest/output.json"));
var document = await SwaggerDocument.FromJsonAsync(output);
//// Assert
Assert.IsTrue(document.ToJson().Contains("\"Bar\": {"));
}
public async Task WhenGeneratingOperationIdsThenMissingIdsAreGenerated()
{
//// Arrange
var json = _sampleServiceCode;
//// Act
var document = await SwaggerDocument.FromJsonAsync(json);
document.GenerateOperationIds();
//// Assert
Assert.AreEqual("pets", document.Operations.First().Operation.OperationId);
}
//[TestMethod]
public async Task When_aspnetcore2swagger_is_called_then_file_is_created()
{
//// Arrange
var projectPath = Path.GetFullPath("../../../NSwag.Sample.NetCoreAngular/NSwag.Sample.NetCoreAngular.csproj");
var command = $"aspnetcore2swagger /project:\"{projectPath}\" /output:\"{DefaultOutputPath}\" /verbose:true";
//// Act
var output = RunCommandLine(command, DefaultOutputPath);
var document = await SwaggerDocument.FromJsonAsync(output);
//// Assert
Assert.IsNotNull(document);
}
public async Task When_generating_operation_ids_then_missing_ids_are_generated()
{
//// Arrange
var json = _sampleServiceCode;
//// Act
var document = await SwaggerDocument.FromJsonAsync(json);
document.GenerateOperationIds();
//// Assert
Assert.Equal("pets", document.Operations.First().Operation.OperationId);
}
public override async Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host)
{
JsonReferenceResolver ReferenceResolverFactory(SwaggerDocument d) =>
new JsonAndYamlReferenceResolver(new JsonSchemaResolver(d, Settings));
var documentJson = await RunIsolatedAsync((string)null);
var document = await SwaggerDocument.FromJsonAsync(documentJson, null, OutputType, ReferenceResolverFactory).ConfigureAwait(false);
await this.TryWriteDocumentOutputAsync(host, () => document).ConfigureAwait(false);
return(document);
}
/// <summary>Generates the Swagger definition for the given classes without operations (used for class generation).</summary>
/// <param name="classNames">The class names.</param>
/// <returns>The Swagger definition.</returns>
public async Task <SwaggerDocument> GenerateAsync(string[] classNames)
{
var assemblyPath = Settings.AssemblySettings.AssemblyPaths.First();
var assemblyDirectory = Path.GetDirectoryName(Path.GetFullPath(assemblyPath));
using (var isolated = new AppDomainIsolation <NetAssemblyLoader>(
assemblyDirectory, Settings.AssemblySettings.AssemblyConfig, AssemblyLoaderUtilities.GetBindingRedirects(), AssemblyLoaderUtilities.GetAssemblies(assemblyDirectory)))
{
var json = await Task.Run(() => isolated.Object.FromAssemblyType(classNames, JsonConvert.SerializeObject(Settings))).ConfigureAwait(false);
return(await SwaggerDocument.FromJsonAsync(json).ConfigureAwait(false));
}
}
private async Task <SwaggerDocument> CreateDocumentAsync(ApiDescriptionGroupCollection apiDescriptionGroups)
{
var document = !string.IsNullOrEmpty(Settings.DocumentTemplate) ? await SwaggerDocument.FromJsonAsync(Settings.DocumentTemplate).ConfigureAwait(false) : new SwaggerDocument();
document.Generator = $"NSwag v{SwaggerDocument.ToolchainVersion} (NJsonSchema v{JsonSchema4.ToolchainVersion})";
document.Info = new SwaggerInfo
{
Title = Settings.Title,
Description = Settings.Description,
Version = Settings.Version,
};
return(document);
}
/// <summary>
/// A constructor that creates a Swagger object from a file
/// </summary>
/// <param name="swaggerPath">Path to Swagger file</param>
public Swagger(string swaggerPath)
{
SwaggerDocument document;
if (Path.GetExtension(swaggerPath) == ".json")
{
document = SwaggerDocument.FromFileAsync(swaggerPath).Result;
}
else
{
var fs = new FileStream(swaggerPath, FileMode.Open);
var reader = new StreamReader(fs);
var deserializer = new Deserializer(namingConvention: new CamelCaseNamingConvention()); //TODO this is deprecated, update to use deserializer
var yamlObject = deserializer.Deserialize(reader);
// now convert the object to JSON. Simple!
JsonSerializer js = new JsonSerializer();
var writer = new StringWriter();
js.Serialize(writer, yamlObject);
string jsonText = writer.ToString();
document = SwaggerDocument.FromJsonAsync(jsonText).Result;
}
Routes = new Dictionary <string, List <Action> >();
document.Operations.ToList().ForEach(operationDescription =>
{
var path = operationDescription.Path.Trim('/').ToLower();
List <Action> methods;
if (Routes.TryGetValue(path, out methods))
{
methods.Add(new Action(operationDescription));
}
else
{
Routes.Add(path, new List <Action>()
{
new Action(operationDescription)
});
}
});
foreach (var r in Routes.Values)
{
Endpoints += r.Count();
}
;
}
internal static SwaggerDocument DownloadDefinition(string uri, ConnectionProperties props, ICredentials credentials = null)
{
var client = new WebClient();
if (credentials != null)
{
client.Credentials = credentials;
}
using (ExecutionContext.SuppressFlow())
{
var swaggerDefinition = client.DownloadString(uri);
return(SwaggerDocument.FromJsonAsync(swaggerDefinition).Result);
}
}
/// <summary>Generates the Swagger definition for the given classes without operations (used for class generation).</summary>
/// <param name="classNames">The class names.</param>
/// <returns>The Swagger definition.</returns>
public override async Task <SwaggerDocument> GenerateAsync(string[] classNames)
{
#if FullNet
using (var isolated = new AppDomainIsolation <NetAssemblyLoader>(Path.GetDirectoryName(Path.GetFullPath(Settings.AssemblyPath)), Settings.AssemblyConfig))
{
var json = await Task.Run(() => isolated.Object.FromAssemblyType(classNames, JsonConvert.SerializeObject(Settings))).ConfigureAwait(false);
return(await SwaggerDocument.FromJsonAsync(json).ConfigureAwait(false));
}
#else
var loader = new NetAssemblyLoader();
var data = loader.FromAssemblyType(classNames, JsonConvert.SerializeObject(Settings));
return(await SwaggerDocument.FromJsonAsync(data).ConfigureAwait(false));
#endif
}
public async Task When_request_body_is_added_then_serialized_correctly_in_OpenApi()
{
//// Arrange
var document = CreateDocument();
//// Act
var json = document.ToJson(SchemaType.OpenApi3);
document = await SwaggerDocument.FromJsonAsync(json);
//// Assert
var requestBody = document.Paths["/baz"][SwaggerOperationMethod.Get].RequestBody;
Assert.Equal("foo", requestBody.Name);
}
/// <summary>Loads the Swagger spec.</summary>
public async Task <SwaggerDocument> RunAsync()
{
if (!string.IsNullOrEmpty(Swagger))
{
return(await SwaggerDocument.FromJsonAsync(Swagger).ConfigureAwait(false));
}
else if (Url.StartsWith("http://") || Url.StartsWith("https://"))
{
return(await SwaggerDocument.FromUrlAsync(Url).ConfigureAwait(false));
}
else
{
return(await SwaggerDocument.FromFileAsync(Url).ConfigureAwait(false));
}
}
/// <summary>Generates the Swagger definition for all controllers in the assembly.</summary>
/// <param name="controllerClassNames">The controller class names.</param>
/// <exception cref="InvalidOperationException">No assembly paths have been provided.</exception>
/// <returns>The Swagger definition.</returns>
public override async Task <SwaggerDocument> GenerateForControllersAsync(IEnumerable <string> controllerClassNames)
{
#if FullNet
using (var isolated = new AppDomainIsolation <WebApiAssemblyLoader>(Path.GetDirectoryName(Path.GetFullPath(Settings.AssemblyPaths.First())), Settings.AssemblyConfig))
{
var document = await Task.Run(() => isolated.Object.GenerateForControllers(controllerClassNames, JsonConvert.SerializeObject(Settings))).ConfigureAwait(false);
return(await SwaggerDocument.FromJsonAsync(document).ConfigureAwait(false));
}
#else
var loader = new WebApiAssemblyLoader();
var data = loader.GenerateForControllers(controllerClassNames, JsonConvert.SerializeObject(Settings));
return(await SwaggerDocument.FromJsonAsync(data).ConfigureAwait(false));
#endif
}
public async Task When_webapi2swagger_is_called_then_file_is_created()
{
//// Arrange
var command = "webapi2swagger " +
"/assembly:" + Path.GetFullPath("../../../NSwag.Demo.Web/bin/NSwag.Demo.Web.dll") + " " +
"/controller:NSwag.Demo.Web.Controllers.PersonsDefaultRouteController " +
"/defaultUrlTemplate:api/{controller}/{action}/{id} " +
"/output:" + DefaultOutputPath;
//// Act
var output = RunCommandLine(command, DefaultOutputPath);
var document = await SwaggerDocument.FromJsonAsync(output);
//// Assert
Assert.IsNotNull(document);
}
public async Task When_schema_is_added_to_definitions_then_it_is_serialized_correctly_in_Swagger()
{
//// Arrange
var document = CreateDocument();
//// Act
var json = document.ToJson(SchemaType.Swagger2);
document = await SwaggerDocument.FromJsonAsync(json, schemaType : SchemaType.OpenApi3);
//// Assert
Assert.Contains("definitions", json);
Assert.DoesNotContain("components", json);
Assert.True(document.Definitions.ContainsKey("Foo"));
}
public async static Task <string> GenerateFromJson(string json, string namespaceName, string className)
{
var document = await SwaggerDocument.FromJsonAsync(json);
var settings = new SwaggerToCSharpClientGeneratorSettings
{
ClassName = className,
CSharpGeneratorSettings =
{
Namespace = namespaceName
}
};
var generator = new SwaggerToCSharpClientGenerator(document, settings);
return(generator.GenerateFile());
}
public async Task WhenConvertingAndBackThenItShouldBeTheSame()
{
//// Arrange
var json = _sampleServiceCode;
//// Act
var document = await SwaggerDocument.FromJsonAsync(json);
var json2 = document.ToJson();
var reference = document.Paths["/pets"][SwaggerOperationMethod.Get].Responses["200"].Schema.Item.SchemaReference;
//// Assert
Assert.IsNotNull(json2);
Assert.IsNotNull(reference);
Assert.AreEqual(3, reference.Properties.Count);
}