public virtual async Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host)
{
if (!string.IsNullOrEmpty(Input) && !Input.StartsWith("/") && !Input.StartsWith("-"))
{
await ExecuteDocumentAsync(host, Input);
}
else
{
var hasNSwagJson = await DynamicApis.FileExistsAsync("nswag.json").ConfigureAwait(false);
if (hasNSwagJson)
{
await ExecuteDocumentAsync(host, "nswag.json");
}
var currentDirectory = await DynamicApis.DirectoryGetCurrentDirectoryAsync().ConfigureAwait(false);
var files = await DynamicApis.DirectoryGetFilesAsync(currentDirectory, "*.nswag").ConfigureAwait(false);
if (files.Any())
{
foreach (var file in files)
{
await ExecuteDocumentAsync(host, file);
}
}
else if (!hasNSwagJson)
{
host.WriteMessage("Current directory does not contain any .nswag files.");
}
}
return(null);
}
public static async Task <bool> TryWriteFileOutputAsync(this IOutputCommand command, string path, IConsoleHost host, Func <string> generator)
{
if (!string.IsNullOrEmpty(path))
{
var directory = DynamicApis.PathGetDirectoryName(path);
if (!string.IsNullOrEmpty(directory) && await DynamicApis.DirectoryExistsAsync(directory).ConfigureAwait(false) == false)
{
await DynamicApis.DirectoryCreateDirectoryAsync(directory).ConfigureAwait(false);
}
var data = generator();
if (!await DynamicApis.FileExistsAsync(path) || await DynamicApis.FileReadAllTextAsync(path) != data)
{
await DynamicApis.FileWriteAllTextAsync(path, data).ConfigureAwait(false);
host?.WriteMessage("Code has been successfully written to file.\n");
}
else
{
host?.WriteMessage("Code has been successfully generated but not written to file (no change detected).\n");
}
return(true);
}
return(false);
}
private async Task TransformAsync(AssemblyLoader.AssemblyLoader assemblyLoader)
{
if (!string.IsNullOrEmpty(DocumentTemplate))
{
if (await DynamicApis.FileExistsAsync(DocumentTemplate).ConfigureAwait(false))
{
Settings.DocumentTemplate = await DynamicApis.FileReadAllTextAsync(DocumentTemplate).ConfigureAwait(false);
}
else
{
Settings.DocumentTemplate = DocumentTemplate;
}
if (!string.IsNullOrEmpty(Settings.DocumentTemplate) && !Settings.DocumentTemplate.StartsWith("{"))
{
Settings.DocumentTemplate = (await SwaggerYamlDocument.FromYamlAsync(Settings.DocumentTemplate)).ToJson();
}
}
else
{
Settings.DocumentTemplate = null;
}
if (DocumentProcessorTypes != null)
{
foreach (var p in DocumentProcessorTypes)
{
var processor = (IDocumentProcessor)assemblyLoader.CreateInstance(p);
Settings.DocumentProcessors.Add(processor);
}
}
if (OperationProcessorTypes != null)
{
foreach (var p in OperationProcessorTypes)
{
var processor = (IOperationProcessor)assemblyLoader.CreateInstance(p);
Settings.OperationProcessors.Add(processor);
}
}
if (!string.IsNullOrEmpty(TypeNameGeneratorType))
{
Settings.TypeNameGenerator = (ITypeNameGenerator)assemblyLoader.CreateInstance(TypeNameGeneratorType);
}
if (!string.IsNullOrEmpty(SchemaNameGeneratorType))
{
Settings.SchemaNameGenerator = (ISchemaNameGenerator)assemblyLoader.CreateInstance(SchemaNameGeneratorType);
}
}
public async Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host)
{
if (await DynamicApis.FileExistsAsync("nswag.json").ConfigureAwait(false) == false)
{
await CreateDocumentAsync("nswag.json");
host.WriteMessage("nswag.json file created.");
}
else
{
host.WriteMessage("nswag.json already exists.");
}
return(null);
}
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();
}));
}
/// <exception cref="ArgumentException">The argument 'Input' was empty.</exception>
protected async Task <JsonSchema4> GetJsonSchemaAsync()
{
var input = Input.ToString();
if (string.IsNullOrEmpty(input))
{
throw new ArgumentException("The argument 'Input' was empty.");
}
if (IsJson(input))
{
return(await JsonSchema4.FromJsonAsync(input).ConfigureAwait(false));
}
if (await DynamicApis.FileExistsAsync(input).ConfigureAwait(false))
{
return(await JsonSchema4.FromFileAsync(input).ConfigureAwait(false));
}
return(await JsonSchema4.FromUrlAsync(input).ConfigureAwait(false));
}
/// <exception cref="ArgumentException">The argument 'Input' was empty.</exception>
protected async Task <string> GetInputJsonAsync()
{
var input = Input.ToString();
if (string.IsNullOrEmpty(input))
{
throw new ArgumentException("The argument 'Input' was empty.");
}
if (IsJson(input))
{
return(input);
}
if (await DynamicApis.FileExistsAsync(input).ConfigureAwait(false))
{
return(await DynamicApis.FileReadAllTextAsync(input).ConfigureAwait(false));
}
return(await DynamicApis.HttpGetAsync(input).ConfigureAwait(false));
}
public async Task <SwaggerDocument> RunAsync()
{
return(await Task.Run(async() =>
{
if (!string.IsNullOrEmpty(DocumentTemplate))
{
if (await DynamicApis.FileExistsAsync(DocumentTemplate).ConfigureAwait(false))
{
Settings.DocumentTemplate = await DynamicApis.FileReadAllTextAsync(DocumentTemplate).ConfigureAwait(false);
}
else
{
Settings.DocumentTemplate = DocumentTemplate;
}
}
else
{
Settings.DocumentTemplate = null;
}
var generator = CreateGenerator();
var controllerNames = ControllerNames.Where(s => !string.IsNullOrWhiteSpace(s)).Distinct().ToList();
if (!controllerNames.Any() && Settings.AssemblyPaths?.Length > 0)
{
controllerNames = generator.GetControllerClasses().ToList();
}
var document = await generator.GenerateForControllersAsync(controllerNames).ConfigureAwait(false);
if (ServiceHost == ".")
{
document.Host = string.Empty;
}
else if (!string.IsNullOrEmpty(ServiceHost))
{
document.Host = ServiceHost;
}
if (!string.IsNullOrEmpty(InfoTitle))
{
document.Info.Title = InfoTitle;
}
if (!string.IsNullOrEmpty(InfoVersion))
{
document.Info.Version = InfoVersion;
}
if (!string.IsNullOrEmpty(InfoDescription))
{
document.Info.Description = InfoDescription;
}
if (ServiceSchemes != null && ServiceSchemes.Any())
{
document.Schemes = ServiceSchemes.Select(s => (SwaggerSchema)Enum.Parse(typeof(SwaggerSchema), s, true)).ToList();
}
if (!string.IsNullOrEmpty(ServiceBasePath))
{
document.BasePath = ServiceBasePath;
}
return document;
}));
}