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); }
/// <summary>Loads an existing NSwagDocument.</summary> /// <typeparam name="TDocument">The type.</typeparam> /// <param name="filePath">The file path.</param> /// <param name="mappings">The mappings.</param> /// <returns>The document.</returns> protected static Task <TDocument> LoadAsync <TDocument>(string filePath, IDictionary <Type, Type> mappings) where TDocument : NSwagDocumentBase, new() { return(Task.Run(async() => { var saveFile = false; var data = await DynamicApis.FileReadAllTextAsync(filePath).ConfigureAwait(false); data = TransformLegacyDocument(data, out saveFile); // TODO: Remove this legacy stuff later var settings = GetSerializerSettings(); settings.ContractResolver = new BaseTypeMappingContractResolver(mappings); var document = JsonConvert.DeserializeObject <TDocument>(data, settings); document.Path = filePath; document.ConvertToAbsolutePaths(); document._latestData = JsonConvert.SerializeObject(document, Formatting.Indented, GetSerializerSettings()); if (saveFile) { await document.SaveAsync(); } return document; })); }
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 LoadSwaggerUrlAsync(string url) { var json = string.Empty; await RunTaskAsync(async() => { json = url.StartsWith("http://", StringComparison.InvariantCultureIgnoreCase) || url.StartsWith("https://", StringComparison.InvariantCultureIgnoreCase) ? await DynamicApis.HttpGetAsync(url) : await DynamicApis.FileReadAllTextAsync(url); json = JsonConvert.SerializeObject(JsonConvert.DeserializeObject(json), Formatting.Indented); }); Command.Swagger = json; }
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(); })); }
/// <summary>Loads an existing NSwagDocument.</summary> /// <typeparam name="TDocument">The type.</typeparam> /// <param name="filePath">The file path.</param> /// <param name="variables">The variables.</param> /// <param name="expandEnvironmentVariables">Specifies whether to expand environment variables.</param> /// <param name="mappings">The mappings.</param> /// <returns>The document.</returns> protected static Task <TDocument> LoadAsync <TDocument>( string filePath, string variables, bool expandEnvironmentVariables, IDictionary <Type, Type> mappings) where TDocument : NSwagDocumentBase, new() { return(Task.Run(async() => { var saveFile = false; var data = await DynamicApis.FileReadAllTextAsync(filePath).ConfigureAwait(false); data = TransformLegacyDocument(data, out saveFile); // TODO: Remove this legacy stuff later if (expandEnvironmentVariables) { data = Regex.Replace(Environment.ExpandEnvironmentVariables(data), "[^\\\\]\\\\[^\\\\]", p => p.Value.Replace("\\", "\\\\")); } foreach (var p in ConvertVariables(variables)) { data = data.Replace("$(" + p.Key + ")", p.Value); } var obj = JObject.Parse(data); if (obj["defaultVariables"] != null) { var defaultVariables = obj["defaultVariables"].Value <string>(); foreach (var p in ConvertVariables(defaultVariables)) { data = data.Replace("$(" + p.Key + ")", p.Value); } } var settings = GetSerializerSettings(); settings.ContractResolver = new BaseTypeMappingContractResolver(mappings); var document = FromJson <TDocument>(filePath, data); if (saveFile) { await document.SaveAsync(); } return document; })); }
/// <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)); }
/// <summary>Loads a JSON Schema from a given file path (only available in .NET 4.x).</summary> /// <param name="filePath">The file path.</param> /// <param name="referenceResolverFactory">The JSON reference resolver factory.</param> /// <returns>The JSON Schema.</returns> /// <exception cref="NotSupportedException">The System.IO.File API is not available on this platform.</exception> public static async Task <JsonSchema4> FromFileAsync(string filePath, Func <JsonSchema4, JsonReferenceResolver> referenceResolverFactory) { var data = await DynamicApis.FileReadAllTextAsync(filePath); return(await FromJsonAsync(data, filePath, referenceResolverFactory).ConfigureAwait(false)); }
/// <summary>Creates a JSON Schema from a JSON file.</summary> /// <param name="filePath">The file path.</param> /// <returns>The <see cref="JsonSchema4" />.</returns> public static async Task <JsonSchema4> FromFileAsync(string filePath) { var data = await DynamicApis.FileReadAllTextAsync(filePath).ConfigureAwait(false); return(await FromYamlAsync(data, filePath).ConfigureAwait(false)); }
/// <summary>Creates a Swagger specification from a JSON file.</summary> /// <param name="filePath">The file path.</param> /// <returns>The <see cref="SwaggerDocument" />.</returns> public static async Task <SwaggerDocument> FromFileAsync(string filePath) { var data = await DynamicApis.FileReadAllTextAsync(filePath).ConfigureAwait(false); return(await FromJsonAsync(data, filePath).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; })); }