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 LoadAllDependenciesAsync(List <PackageReferenceInfo> packages, IConsoleHost host) { host.WriteMessage($"Load dependencies "); var tasks = new List <Task>(); foreach (var entry in packages.ToList()) { tasks.Add(LoadDependenciesAsync(entry, packages, tasks, host)); } while (true) { List <Task> list = null; lock (packages) { list = tasks.ToList(); } await Task.WhenAll(list); lock (packages) { if (tasks.All(t => t.IsCompleted)) { break; } } } host.WriteMessage($"\n"); }
public override Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { foreach (var projectPath in GetProjectPaths()) { try { var projectDirectory = System.IO.Path.GetDirectoryName(projectPath); var binDirectory = System.IO.Path.Combine(projectDirectory, "bin"); var objDirectory = System.IO.Path.Combine(projectDirectory, "obj"); if (Directory.Exists(binDirectory)) { Directory.Delete(binDirectory, true); host.WriteMessage("Deleted directory " + binDirectory + "\n"); } if (Directory.Exists(objDirectory)) { Directory.Delete(objDirectory, true); host.WriteMessage("Deleted directory " + objDirectory + "\n"); } } catch (Exception e) { host.WriteError(e + "\n"); } } return(Task.FromResult <object>(null)); }
public override Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { foreach (var projectPath in GetProjectPaths()) { try { using (var projectInformation = ProjectExtensions.LoadProject(projectPath)) { if (projectInformation.Project.GeneratesPackage() || projectInformation.Project.HasVersion()) { var versions = BumpVersion(projectInformation.Project, "Version", "1.0.0"); host.WriteMessage("[x] Bumped version of " + System.IO.Path.GetFileName(projectPath) + " from " + versions.Item2 + " to " + versions.Item1 + "\n"); if (!Simulate) { projectInformation.Project.Save(); } } else { host.WriteMessage("[ ] Ignoring " + System.IO.Path.GetFileName(projectPath) + ": Not GeneratePackageOnBuild\n"); } } } catch (Exception e) { host.WriteError(e + "\n"); } } return(Task.FromResult <object>(null)); }
private async Task ExecuteDocumentAsync(IConsoleHost host, string filePath) { host.WriteMessage("\nExecuting file '" + filePath + "' with variables '" + Variables + "'...\n"); var document = await NSwagDocument.LoadWithTransformationsAsync(filePath, Variables); if (document.Runtime != Runtime.Default) { if (document.Runtime != RuntimeUtilities.CurrentRuntime) { throw new InvalidOperationException("The specified runtime in the document (" + document.Runtime + ") differs " + "from the current process runtime (" + RuntimeUtilities.CurrentRuntime + "). " + "Change the runtime with the '/runtime:" + document.Runtime + "' parameter " + "or run the file with the correct command line binary."); } if (document.SelectedSwaggerGenerator == document.SwaggerGenerators.WebApiToOpenApiCommand && document.SwaggerGenerators.WebApiToOpenApiCommand.IsAspNetCore == false && document.Runtime != Runtime.Debug && document.Runtime != Runtime.WinX86 && document.Runtime != Runtime.WinX64) { throw new InvalidOperationException("The runtime " + document.Runtime + " in the document must be used " + "with ASP.NET Core. Enable /isAspNetCore:true."); } } await document.ExecuteAsync(); host.WriteMessage("Done.\n"); }
public static Task <bool> TryWriteFileOutputAsync(this IOutputCommand command, string path, IConsoleHost host, NewLineBehavior newLineBehavior, Func <string> generator) { if (!string.IsNullOrEmpty(path)) { var directory = DynamicApis.PathGetDirectoryName(path); if (!string.IsNullOrEmpty(directory) && DynamicApis.DirectoryExists(directory) == false) { DynamicApis.DirectoryCreateDirectory(directory); } var data = generator(); data = data?.Replace("\r", "") ?? ""; data = newLineBehavior == NewLineBehavior.Auto ? data.Replace("\n", Environment.NewLine) : newLineBehavior == NewLineBehavior.CRLF ? data.Replace("\n", "\r\n") : data; if (!DynamicApis.FileExists(path) || DynamicApis.FileReadAllText(path) != data) { DynamicApis.FileWriteAllText(path, data); 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(Task.FromResult(true)); } return(Task.FromResult(false)); }
private static void SwitchToProjects(ReferenceSwitcherConfiguration configuration, IConsoleHost host) { var solution = SolutionFile.Parse(configuration.ActualSolution); foreach (var solutionProject in solution.ProjectsInOrder) { if (solutionProject.ProjectType != SolutionProjectType.SolutionFolder) { try { using (var projectInformation = ProjectExtensions.LoadProject(solutionProject.AbsolutePath)) { foreach (var mapping in configuration.Mappings) { var packageName = mapping.Key; var projectPaths = mapping.Value.Select(p => configuration.GetActualPath(p)).ToList(); var switchedProjects = SwitchToProject(configuration, solutionProject, projectInformation, packageName, projectPaths, host); foreach (var s in switchedProjects) { host.WriteMessage("Project " + Path.GetFileName(s.Key) + " packages:\n"); host.WriteMessage(" " + packageName + " v" + s.Value + "\n replaced by:\n"); projectPaths.ForEach(p => host.WriteMessage(" " + Path.GetFileName(p) + "\n")); } } } } catch (Exception e) { host.WriteError("The project '" + solutionProject.AbsolutePath + "' could not be loaded: " + e.Message + "\n"); } } } }
public override async Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { if (!string.IsNullOrEmpty(File)) { var document = await NSwagDocument.LoadWithTransformationsAsync(File, Variables); var command = (TypesToSwaggerCommand)document.SelectedSwaggerGenerator; AssemblyPaths = command.AssemblyPaths; AssemblyConfig = command.AssemblyConfig; ReferencePaths = command.ReferencePaths; } var classNames = await RunIsolatedAsync(!string.IsNullOrEmpty(File)?Path.GetDirectoryName(File) : null); host.WriteMessage("\r\n"); foreach (var className in classNames) { host.WriteMessage(className + "\r\n"); } host.WriteMessage("\r\n"); return(classNames); }
private async Task ExecuteDocumentAsync(IConsoleHost host, string filePath) { host.WriteMessage("\nExecuting file '" + filePath + "'...\n"); var document = await LoadDocumentAsync(filePath); await document.ExecuteAsync(); host.WriteMessage("Done.\n"); }
public static async Task <int> RunAsync( string executable, IReadOnlyList <string> args, IConsoleHost console = null, TimeSpan?timeout = null) { var arguments = ToArguments(args); var startInfo = new ProcessStartInfo { FileName = executable, Arguments = arguments, UseShellExecute = false, RedirectStandardOutput = console != null, RedirectStandardError = console != null, }; console?.WriteMessage($"Executing {executable} {arguments}{Environment.NewLine}"); using (var process = Process.Start(startInfo)) { var tcs = new TaskCompletionSource <bool>(); process.EnableRaisingEvents = true; process.Exited += (_, eventArgs) => { if (process.ExitCode == 0) { tcs.TrySetResult(true); } else { tcs.TrySetException(new Exception($"Process failed with non-zero exit code '{process.ExitCode}'.")); } }; if (console != null) { process.OutputDataReceived += (_, eventArgs) => console.WriteMessage(eventArgs.Data + Environment.NewLine); process.ErrorDataReceived += (_, eventArgs) => console.WriteError(eventArgs.Data + Environment.NewLine); process.BeginErrorReadLine(); process.BeginOutputReadLine(); } var result = await Task.WhenAny(tcs.Task, Task.Delay(timeout ?? TimeSpan.FromSeconds(60 * 5))).ConfigureAwait(false); if (result != tcs.Task) { throw new InvalidOperationException($"Process {startInfo.FileName} timed out."); } else { console?.WriteMessage($"Done executing command. Exit Code: {process.ExitCode}.{Environment.NewLine}"); return(process.ExitCode); } } }
protected void WriteOutput(IConsoleHost host, string output) { if (string.IsNullOrEmpty(Output)) host.WriteMessage(output); else { File.WriteAllText(Output, output, Encoding.UTF8); host.WriteMessage("Client code successfully written to file."); } }
/// <summary> /// Read the command name using console host if it was not provided by call. /// </summary> /// <returns>Command name input by user</returns> private string ReadCommandNameInteractive() { _consoleHost.WriteMessage("Commands: \n"); foreach (var command in Commands) { _consoleHost.WriteMessage(" " + command.Key + "\n"); } return(_consoleHost.ReadValue("Command: ")); }
private async Task ExecuteDocumentAsync(IConsoleHost host, string filePath) { host.WriteMessage("\nExecuting file '" + filePath + "'...\n"); var document = await LoadDocumentAsync(filePath); await document.ExecuteAsync(); host.WriteMessage("Done.\n"); }
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously public async Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host) #pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously { //Connect and create users collection for LiteDB.org //LiteDB connection LiteDatabase db = new LiteDatabase(@"UsersObjects.db"); //Get users collection var col = db.GetCollection <Users>("users"); //Create Scrypt Password ScryptEncoder encoder = new ScryptEncoder(); string hashsedPassword = encoder.Encode(SecondValue); if (col.Count() == 0) { // Create your new customer instance var user = new Users { UserName = FirstValue, UserPassword = hashsedPassword, IsActive = true }; // Create unique index in Name field col.EnsureIndex(x => x.UserName, true); // Insert new customer document (Id will be auto-incremented) col.Insert(user); ShowInfo(host, hashsedPassword); } else { // Create your new customer instance var user = new Users { UserName = FirstValue, UserPassword = hashsedPassword, IsActive = true }; // Insert new customer document (Id will be auto-incremented) try { col.Insert(user); ShowInfo(host, hashsedPassword); } catch (LiteDB.LiteException e) { host.WriteMessage("ERROR: " + e.Message); host.WriteMessage("\n"); } } return(null); }
public override Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { if (Version.IndexOf(".") < 0) { host.WriteError("Version number must include at least two parts \n"); return(Task.FromResult <object>(null)); } bool isReplaceOnly = !ACTION_FORCE.Equals(Action, StringComparison.InvariantCultureIgnoreCase); var globalProperties = TryGetGlobalProperties(); foreach (var projectPath in GetProjectPaths()) { try { using (var projectInformation = ProjectExtensions.LoadProject(projectPath, globalProperties)) { bool projectHasVersion = projectInformation.Project.HasVersion(); bool projectGeneratesPackage = projectInformation.Project.GeneratesPackage(); if (projectGeneratesPackage && (projectHasVersion || !isReplaceOnly)) { var versions = ChangeVersion(projectInformation.Project, "Version"); if (!versions.Item1.Equals(versions.Item2)) { host.WriteMessage($"[x] {(projectHasVersion ? "Replaced" : "Set")} version of {System.IO.Path.GetFileName(projectPath)}" + " from " + versions.Item2 + " to " + versions.Item1 + "\n"); if (!Simulate) { projectInformation.Project.Save(); } } else { host.WriteMessage($"[ ] Skipping {System.IO.Path.GetFileName(projectPath)} is already set to {versions.Item1}\n"); } } else { host.WriteMessage($"[ ] Ignoring {System.IO.Path.GetFileName(projectPath)}: {( !projectGeneratesPackage ? "Not GeneratePackageOnBuild" : "No version in Project")}\n"); } } } catch (Exception e) { host.WriteError(e + "\n"); } } return(Task.FromResult <object>(null)); }
protected void WriteOutput(IConsoleHost host, string output) { if (string.IsNullOrEmpty(OutputFilePath)) { host.WriteMessage(output); } else { File.WriteAllText(OutputFilePath, output, Encoding.UTF8); host.WriteMessage("Code has been successfully written to file.\n"); } }
public async Task<object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { if (!DynamicApis.FileExists("nswag.json")) { await CreateDocumentAsync("nswag.json"); host.WriteMessage("nswag.json file created."); } else host.WriteMessage("nswag.json already exists."); return null; }
public override Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { var globalProperties = TryGetGlobalProperties(); foreach (var projectPath in GetProjectPaths()) { try { using (var projectInformation = ProjectExtensions.LoadProject(projectPath, globalProperties)) { var project = projectInformation.Project; var result = false; switch (Action) { case "warnaserror": result = EnableBooleanProperty(project, "TreatWarningsAsErrors"); break; case "xmldocs": result = EnableXmlDocs(project); break; default: throw new ArgumentException("The feature " + Action + " is not available."); } if (result) { host.WriteMessage("[x] Enabled feature " + Action + " in project " + System.IO.Path.GetFileName(projectPath) + "\n"); if (!Simulate) { project.Save(); } } else { host.WriteMessage("[ ] Feature " + Action + " already enabled in project " + System.IO.Path.GetFileName(projectPath) + "\n"); } } } catch (Exception e) { host.WriteError(e + "\n"); } } return(Task.FromResult <object>(null)); }
private void PrintCommand(IConsoleHost host, KeyValuePair<string, Type> pair) { var commandType = pair.Value; host.WriteMessage("---------------------\n"); host.WriteMessage("Command: "); host.WriteMessage(pair.Key + "\n"); var descriptionAttribute = commandType.GetCustomAttribute<DescriptionAttribute>(); if (descriptionAttribute != null) host.WriteMessage(" " + descriptionAttribute.Description + "\n"); host.WriteMessage("\nArguments: \n"); foreach (var property in commandType.GetRuntimeProperties()) { var argumentAttribute = property.GetCustomAttribute<ArgumentAttribute>(); if (argumentAttribute != null) { if (argumentAttribute.Position > 0) host.WriteMessage(" Argument Position " + argumentAttribute.Position + "\n"); else host.WriteMessage(" " + argumentAttribute.Name.ToLowerInvariant() + "\n"); var parameterDescriptionAttribute = property.GetCustomAttribute<DescriptionAttribute>(); if (parameterDescriptionAttribute != null) host.WriteMessage(" " + parameterDescriptionAttribute.Description + "\n"); } } }
private void LoadProjects(IConsoleHost host, List <PackageReferenceInfo> packages) { host.WriteMessage($"Loading projects "); var globalProperties = TryGetGlobalProperties(); foreach (var projectPath in GetProjectPaths()) { try { using (var projectInformation = ProjectExtensions.LoadProject(projectPath, globalProperties)) { foreach (var item in projectInformation.Project.Items.Where(i => i.ItemType == "PackageReference").ToList()) { var packageName = item.EvaluatedInclude; var packageVersion = item.Metadata.SingleOrDefault(m => m.Name == "Version")?.EvaluatedValue ?? "Latest"; if (packageName != "NETStandard.Library" && (!ExcludeSystem || !packageName.StartsWith("System.")) && (!ExcludeMicrosoft || !packageName.StartsWith("Microsoft."))) { var entry = packages.SingleOrDefault(p => p.Name == packageName && p.Version == packageVersion); if (entry == null) { entry = new PackageReferenceInfo { Name = packageName, Version = packageVersion, Type = "t" }; packages.Add(entry); } else { entry.Count++; } host.WriteMessage("."); } } } } catch (Exception e) { host.WriteError(e + "\n"); } } host.WriteMessage($"\n"); }
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); }
/// <summary>Gets the name of the command to execute.</summary> /// <param name="args">The arguments.</param> /// <returns>The command name.</returns> protected string GetCommandName(string[] args) { if (args.Length == 0 || args[0].Length == 0 || !char.IsLetter(args[0][0])) { _consoleHost.WriteMessage("Commands: \n"); foreach (var command in Commands) { _consoleHost.WriteMessage(" " + command.Key + "\n"); } return(_consoleHost.ReadValue("Command: ").ToLowerInvariant()); } return(args[0].ToLowerInvariant()); }
public async Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { if (!string.IsNullOrEmpty(Input) && !Input.StartsWith("/") && !Input.StartsWith("-")) { await ExecuteDocumentAsync(host, Input); } else { var hasNSwagJson = DynamicApis.FileExists("nswag.json"); if (hasNSwagJson) { await ExecuteDocumentAsync(host, "nswag.json"); } var currentDirectory = DynamicApis.DirectoryGetCurrentDirectory(); var files = DynamicApis.DirectoryGetFiles(currentDirectory, "*.nswag"); 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 override async Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { var packages = new List <PackageReferenceInfo>(); LoadProjects(host, packages); await LoadAllDependenciesAsync(packages, host); await LoadLicensesAsync(packages, host); host.WriteMessage($"{"Package",-85} {"Version",-22} {"Type",-5} {"#",-3} {"License",-15} {"License URL"}\n"); foreach (var entry in packages.OrderBy(p => p.Name).ThenBy(p => p.Version)) { host.WriteMessage($"{entry.Name,-85} {entry.Version,-22} {entry.Type,-5} {entry.Count,-3} {entry.License,-15} {entry.LicenseUri,-10}\n"); } return(Task.FromResult <object>(null)); }
public override async Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { return(await Task.Run(async() => { var generator = await CreateGeneratorAsync(); var classNames = generator.GetExportedClassNames(); host.WriteMessage("\r\n"); foreach (var className in classNames) { host.WriteMessage(className + "\r\n"); } host.WriteMessage("\r\n"); return classNames; })); }
private void PrintCommand(IConsoleHost host, KeyValuePair <string, Type> pair) { var commandType = pair.Value; host.WriteMessage("\nCommand: "); host.WriteMessage(pair.Key + "\n"); var commandAttribute = commandType.GetTypeInfo().GetCustomAttribute <CommandAttribute>(); if (commandAttribute != null && !string.IsNullOrEmpty(commandAttribute.Description)) { host.WriteMessage(" " + commandAttribute.Description + "\n"); } else { dynamic descriptionAttribute = commandType.GetTypeInfo().GetCustomAttributes().SingleOrDefault(a => a.GetType().Name == "DescriptionAttribute"); if (descriptionAttribute != null) { host.WriteMessage(" " + descriptionAttribute.Description + "\n"); } } host.WriteMessage("\nArguments: \n"); foreach (var property in commandType.GetRuntimeProperties()) { var argumentAttribute = property.GetCustomAttribute <ArgumentAttribute>(); if (argumentAttribute != null && !string.IsNullOrEmpty(argumentAttribute.Name)) { if (argumentAttribute.Position > 0) { host.WriteMessage(" Argument Position " + argumentAttribute.Position + "\n"); } else { host.WriteMessage(" " + argumentAttribute.Name + "\n"); } if (!string.IsNullOrEmpty(argumentAttribute.Description)) { host.WriteMessage(" " + argumentAttribute.Description + "\n"); } dynamic parameterDescriptionAttribute = property.GetCustomAttributes().SingleOrDefault(a => a.GetType().Name == "DescriptionAttribute"); if (parameterDescriptionAttribute != null) { host.WriteMessage(" " + parameterDescriptionAttribute.Description + "\n"); } } } }
private async Task LoadLicensesAsync(List <PackageReferenceInfo> packages, IConsoleHost host) { var resource = await CreatePackageMetadataResourceAsync(); host.WriteMessage($"Loading licenses "); var httpClient = new HttpClient(); var tasks = new List <Task>(); foreach (var entry in packages.ToList()) { tasks.Add(LoadLicenseAsync(httpClient, entry, host)); } await Task.WhenAll(tasks); host.WriteMessage($"\n\n"); }
private void SwitchToPackages(IConsoleHost host, ReferenceSwitcherConfiguration configuration) { var solution = SolutionFile.Parse(configuration.ActualSolution); foreach (var mapping in configuration.Mappings) { var projectPath = mapping.Value.ActualPath; var packageName = mapping.Key; var packageVersion = mapping.Value.Version; var switchedProjects = SwitchToPackage(solution, projectPath, packageName, packageVersion, host); foreach (var s in switchedProjects) { host.WriteMessage(Path.GetFileName(s) + ": \n"); host.WriteMessage(" " + Path.GetFileName(projectPath) + " => " + packageName + " v" + packageVersion + "\n"); } } }
public override Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { foreach (var projectPath in GetProjectPaths()) { ConsoleUtilities.WriteColor(System.IO.Path.GetFileName(projectPath) + ":\n", ConsoleColor.Green); host.WriteMessage(projectPath.Replace(Directory.GetCurrentDirectory(), "") + "\n"); } return(Task.FromResult <object>(null)); }
public override Task <object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { var globalProperties = TryGetGlobalProperties(); foreach (var projectPath in GetProjectPaths()) { try { using (var projectInformation = ProjectExtensions.LoadProject(projectPath, globalProperties)) { var project = projectInformation.Project; foreach (var diagnosticsId in DiagnosticsIds.Split(';')) { var noWarnItem = project.Properties.FirstOrDefault(i => i.Name.ToLowerInvariant() == "nowarn"); if (noWarnItem == null || noWarnItem.IsImported) { noWarnItem = project.SetProperty("NoWarn", diagnosticsId); host.WriteMessage($"[x] Added no warn '{diagnosticsId}' tag to project " + System.IO.Path.GetFileName(projectPath) + "\n"); } else if (!noWarnItem.EvaluatedValue.Split(';').Contains(diagnosticsId)) { noWarnItem.UnevaluatedValue = noWarnItem.EvaluatedValue + ";" + diagnosticsId; host.WriteMessage($"[x] Added no warn '{diagnosticsId}' to existing tag to project " + System.IO.Path.GetFileName(projectPath) + "\n"); } else { host.WriteMessage($"[ ] No warn '{diagnosticsId}' already exists in project " + System.IO.Path.GetFileName(projectPath) + "\n"); } } ProjectExtensions.SaveWithLineEndings(projectInformation); } } catch (Exception e) { host.WriteError(e + "\n"); } } return(Task.FromResult <object>(null)); }
private static void SwitchToPackages(IConsoleHost host, ReferenceSwitcherConfiguration configuration) { var solution = SolutionFile.Parse(configuration.ActualSolution); var globalProperties = ProjectExtensions.GetGlobalProperties(Path.GetFullPath(configuration.ActualSolution)); var mappedProjectFilePaths = configuration.Mappings.Values .SelectMany(x => x) .Select(p => Path.GetFileName(p)) .ToList(); foreach (var solutionProject in solution.ProjectsInOrder) { if (solutionProject.ProjectType != SolutionProjectType.SolutionFolder && ProjectExtensions.IsSupportedProject(solutionProject.AbsolutePath)) { try { using (var projectInformation = ProjectExtensions.LoadProject(solutionProject.AbsolutePath, globalProperties)) { foreach (var mapping in configuration.Mappings) { var projectPaths = mapping.Value.Select(p => configuration.GetActualPath(p)).ToList(); var packageName = mapping.Key; var switchedProjects = SwitchToPackage( configuration, solutionProject, projectInformation, projectPaths, packageName, mappedProjectFilePaths, host); if (switchedProjects.Count > 0) { host.WriteMessage("Project " + solutionProject.ProjectName + " with project references:\n"); projectPaths.ForEach(p => host.WriteMessage(" " + Path.GetFileName(p) + "\n")); host.WriteMessage(" replaced by package: " + packageName + " v" + switchedProjects.First().PackageVersion + "\n"); } } } } catch (Exception e) { host.WriteError($"The project '{solutionProject.AbsolutePath}' could not be loaded: {e}\n"); } } } }
protected void WriteOutput(IConsoleHost host, string output) { if (string.IsNullOrEmpty(OutputFilePath)) { host.WriteMessage(output); } else { var file = new FileInfo(OutputFilePath); var directory = file.Directory; if (!directory.Exists) { directory.Create(); } File.WriteAllText(OutputFilePath, output, Encoding.UTF8); host.WriteMessage("Code has been successfully written to file.\n"); } }
protected async Task ExecuteCommandAsync(string command, string arguments, IConsoleHost host) { if (Simulate) { host.WriteMessage("SIMULATE " + command); } else { await ProcessUtilities.ExecuteAsync(command, arguments, Verbose); } }
/// <summary>Processes the command line arguments.</summary> /// <param name="args">The arguments.</param> /// <returns>The result.</returns> public int Process(string[] args) { _host.WriteMessage("toolchain v" + SwaggerDocument.ToolchainVersion + " (NJsonSchema v" + JsonSchema4.ToolchainVersion + ")\n"); _host.WriteMessage("Visit http://NSwag.org for more information.\n"); WriteBinDirectory(); if (args.Length == 0) { _host.WriteMessage("Execute the 'help' command to show a list of all the available commands.\n"); } try { var processor = new CommandLineProcessor(_host); processor.RegisterCommandsFromAssembly(typeof(SwaggerToCSharpControllerCommand).GetTypeInfo().Assembly); var stopwatch = new Stopwatch(); stopwatch.Start(); processor.Process(args); stopwatch.Stop(); _host.WriteMessage("\nDuration: " + stopwatch.Elapsed + "\n"); } catch (Exception exception) { _host.WriteError(exception.ToString()); return(-1); } WaitWhenDebuggerAttached(); return(0); }
public async Task<object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { if (!string.IsNullOrEmpty(Input)) await ExecuteDocumentAsync(host, Input); else { if (DynamicApis.FileExists("nswag.json")) await ExecuteDocumentAsync(host, "nswag.json"); var files = DynamicApis.DirectoryGetFiles(DynamicApis.DirectoryGetCurrentDirectory(), "*.nswag"); if (files.Any()) { foreach (var file in files) await ExecuteDocumentAsync(host, file); } else host.WriteMessage("Current directory does not contain any .nswag files."); } return null; }
private void PrintCommand(IConsoleHost host, KeyValuePair<string, Type> pair) { var commandType = pair.Value; host.WriteMessage("\n"); host.WriteMessage("USAGE\n"); host.WriteMessage("=====\n"); host.WriteMessage("myapp.exe myCommand /myParameter:myValue /mySecondParameter:myValue\n\n\n"); host.WriteMessage("AVAILABLE COMMANDS\n"); host.WriteMessage("==================\n\n"); host.WriteMessage("Command: "); host.WriteMessage(pair.Key + "\n"); var commandAttribute = commandType.GetTypeInfo().GetCustomAttribute<CommandAttribute>(); if (commandAttribute != null && !string.IsNullOrEmpty(commandAttribute.Description)) host.WriteMessage(" " + commandAttribute.Description + "\n"); else { dynamic descriptionAttribute = commandType.GetTypeInfo().GetCustomAttributes().SingleOrDefault(a => a.GetType().Name == "DescriptionAttribute"); if (descriptionAttribute != null) host.WriteMessage(" " + descriptionAttribute.Description + "\n"); } host.WriteMessage("\nArguments: \n"); foreach (var property in commandType.GetRuntimeProperties()) { var argumentAttribute = property.GetCustomAttribute<ArgumentAttribute>(); if (argumentAttribute != null && !string.IsNullOrEmpty(argumentAttribute.Name)) { if (argumentAttribute.Position > 0) host.WriteMessage(" Argument Position " + argumentAttribute.Position + "\n"); else host.WriteMessage(" " + argumentAttribute.Name + "\n"); if (!string.IsNullOrEmpty(argumentAttribute.Description)) host.WriteMessage(" " + argumentAttribute.Description + "\n"); dynamic parameterDescriptionAttribute = property.GetCustomAttributes().SingleOrDefault(a => a.GetType().Name == "DescriptionAttribute"); if (parameterDescriptionAttribute != null) host.WriteMessage(" " + parameterDescriptionAttribute.Description + "\n"); } } }
/// <summary>Runs the command.</summary> /// <param name="processor">The processor.</param> /// <param name="host">The host.</param> /// <returns>The output.</returns> public Task<object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { host.WriteMessage("\nNSwag version: " + SwaggerDocument.ToolchainVersion + "\n"); host.WriteMessage("NJsonSchema version: " + JsonSchema4.ToolchainVersion + "\n"); return Task.FromResult<object>(null); }
public async Task<object> RunAsync(CommandLineProcessor processor, IConsoleHost host) { host.WriteMessage(string.Format("Clone {{ Repository={0}, Quiet={1} }}", Repository, Quiet)); return null; }