static void Main(string[] args)
{
var rootCommand = new RootCommand();
{
var fileCommand = new Command("file");
rootCommand.AddCommand(fileCommand);
var io = new Option <string>("--input", description: "The file to trim.");
io.AddAlias("-i");
fileCommand.AddOption(io);
fileCommand.Handler = CommandHandler.Create <string>(async(string input) =>
{
//Parse a file of markers into an in-out list for use with the automator.
var engine = new Engine(SmpteFrameRate.Smpte25, 10.0);
await engine.ParseMarkersFileAsync(input);
});
}
{
var directoryCommand = new Command("directory");
rootCommand.AddCommand(directoryCommand);
var io = new Option <string>("--input", description: "The file to trim.");
io.AddAlias("-i");
directoryCommand.AddOption(io);
directoryCommand.Handler = CommandHandler.Create <string>(async(string input) =>
{
foreach (var fi in new DirectoryInfo(input).GetFiles())
{
//Parse a file of markers into an in-out list for use with the automator.
var engine = new Engine(SmpteFrameRate.Smpte25, 15.0);
await engine.ParseMarkersFileAsync(fi.FullName);
}
});
}
rootCommand.Invoke(args);
}
public int Run(string[] args)
{
Logger.Info(() => "Logging configured.");
var rootCommand = new RootCommand();
var buildCommand = new Command("build", "Generates C# code, database model file and other project assets.");
// CurrentDirectory by default, because rhetos.exe on *build* is expected to be located in NuGet package cache.
buildCommand.Add(new Argument <DirectoryInfo>("project-root-folder", () => new DirectoryInfo(Environment.CurrentDirectory))
{
Description = "Project folder where csproj file is located. If not specified, current working directory is used by default."
});
buildCommand.Add(new Option <bool>("--msbuild-format", false, "Adjust error output format for MSBuild integration."));
buildCommand.Handler = CommandHandler.Create((DirectoryInfo projectRootFolder, bool msbuildFormat)
=> ReportError(() => Build(projectRootFolder.FullName), msbuildFormat));
rootCommand.AddCommand(buildCommand);
var dbUpdateCommand = new Command("dbupdate", "Updates the database structure and initializes the application data in the database.");
dbUpdateCommand.Add(new Argument <DirectoryInfo>("application-folder", () => new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory))
{
Description = "If not specified, it will search for the application at rhetos.exe location and parent directories."
});
dbUpdateCommand.Add(new Option <bool>("--short-transactions", "Commit transaction after creating or dropping each database object."));
dbUpdateCommand.Add(new Option <bool>("--skip-recompute", "Skip automatic update of computed data with KeepSynchronized. See output log for data that needs updating."));
dbUpdateCommand.Handler = CommandHandler.Create((DirectoryInfo applicationFolder, bool shortTransactions, bool skipRecompute)
=> ReportError(() => DbUpdate(applicationFolder, shortTransactions, skipRecompute)));
rootCommand.AddCommand(dbUpdateCommand);
return(rootCommand.Invoke(args));
}
public static async Task Invokes_DerivedClass()
{
var service = new MyService();
var cmd = new RootCommand();
cmd.AddCommand(new MyCommand());
cmd.AddCommand(new MyOtherCommand());
var parser = new CommandLineBuilder(cmd)
.UseHost((builder) => {
builder.ConfigureServices(services =>
{
services.AddTransient(x => service);
})
.UseCommandHandler <MyCommand, MyCommand.MyDerivedHandler>()
.UseCommandHandler <MyOtherCommand, MyOtherCommand.MyDerivedHandler>();
})
.Build();
await parser.InvokeAsync(new string[] { "mycommand", "--int-option", "54" });
service.Value.Should().Be(54);
await parser.InvokeAsync(new string[] { "myothercommand", "TEST" });
service.StringValue.Should().Be("TEST");
}
public static Task <int> Main(string[] args)
{
if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
Console.WriteLine("This tool is not supported on non-Windows platforms due to dependencies on Visual Studio.");
return(Task.FromResult(ErrorCodes.PlatformNotSupported));
}
var root = new RootCommand
{
// Get name from process so that it will show correctly if run as a .NET CLI tool
Name = GetProcessName(),
};
#if ANALYZE_COMMAND
var upgradeCmd = new Command("upgrade");
ConfigureUpgradeCommand(upgradeCmd);
root.AddCommand(upgradeCmd);
var analyzeCmd = new Command("analyze");
ConfigureAnalyzeCommand(analyzeCmd);
root.AddCommand(analyzeCmd);
#else
ConfigureUpgradeCommand(root);
#endif
return(new CommandLineBuilder(root)
.UseDefaults()
.UseHelpBuilder(b => new HelpWithHeader(b.Console))
.Build()
.InvokeAsync(args));
public static void RegisterCommands(RootCommand rootCommand)
{
rootCommand.AddCommand(new Command("list", "Lists installed packages")
{
Handler = CommandHandler.Create(List)
});
Command search = new Command("search", "Search for packages")
{
new Option <string>(new[] { "--identifier", "-i" }, "Something to identify the app")
{
Required = true
}
};
search.Handler = CommandHandler.Create <string>(Search);
rootCommand.AddCommand(search);
Command show = new Command("show", "Shows package info")
{
new Option <string>(new[] { "--identifier", "-i" }, "Something to identify the app")
{
Required = true
}
};
show.Handler = CommandHandler.Create <string>(Show);
rootCommand.AddCommand(show);
rootCommand.AddCommand(new Command("update", "Updates the cache")
{
Handler = CommandHandler.Create(Update)
});
}
/// <summary>
/// Takes a list of gamertags in csv format (with their xuid and last weeks gamerscore),
/// polls the open XBL api for their current gamerscore and outputs the (weekly) leaderboard
/// in a table format Discourse understands.
///
/// operates in 2 different modes:
/// - if the caller specifies option --weekly the programm scans the path for the last
/// weekly file, calculates the weekly diff and writes the new weekly and global scores
/// to a new file in the path. it also writes a second text file in Discourse format.
/// - if the caller specifies option --monthly the programm first scans all users for
/// the highest score for the monthly game (this games name is either specified on the
/// commandline or in lastscanstats.txt). The the program searches the path for the last
/// monthly file, calculates the monthly diff and writes the new monthly and global scores
/// to a new file in the path. it also writes a second text file in Discourse format.
/// </summary>
public static int Main(string[] args)
{
var gameOption = new Option <string>(name: "--game",
description: "title-id of monthly game",
getDefaultValue: () => string.Empty);
var pathArg = new Argument <string>(name: "path",
description: "path to scores scores directory",
getDefaultValue: () => @"./docs/scores");
var rootCommand = new RootCommand("Batch app for building the weekly or monthly Xboxera leaderboard");
var weeklyCommand = new Command("weekly", "generate weekly leaderboard data");
weeklyCommand.AddArgument(pathArg);
weeklyCommand.AddOption(gameOption);
weeklyCommand.SetHandler <string, string>(HandleWeeklyCommand, pathArg, gameOption);
rootCommand.AddCommand(weeklyCommand);
var monthlyCommand = new Command("monthly", "generate monthly leaderboard data");
monthlyCommand.AddArgument(pathArg);
monthlyCommand.AddOption(gameOption);
monthlyCommand.SetHandler <string, string>(HandleMonthlyCommand, pathArg, gameOption);
rootCommand.AddCommand(monthlyCommand);
return(rootCommand.Invoke(args));
}
private static int Main(string[] args)
{
var calc = new Calculation();
var rootCommand = new RootCommand
{
new Option <string>(
"--from",
getDefaultValue: () => "NK",
description: "From currency. Should be of valid currency symbol. Check --symbols for list."),
new Option <string>(
"--to",
getDefaultValue: () => "SEK",
description: "To currency. Should be of valid currency symbol. Check --symbols for list."),
new Option <string>(
"--date",
getDefaultValue: () => "latest",
description: "Date in format yyyy-dd-mm for historical data"),
new Option <decimal>(
"--amount",
getDefaultValue: () => 1,
"Amount of currency to convert in dot decimal format. Amount is given in the 'to' currency.")
};
rootCommand.Description = "Currencyconverter. Takes a valid currency symbol as --to and --from and converts.";
rootCommand.Handler = CommandHandler.Create <string, string, string, decimal>(async(from, to, date, amount) =>
{
var result = await calc.FromToAmount(from.ToUpper(), to.ToUpper(), amount, date);
Console.WriteLine(result);
});
rootCommand.AddCommand(getSymbols());
rootCommand.AddCommand(getAllRates());
// Parse the incoming args and invoke the handler
return(rootCommand.InvokeAsync(args).Result);
}
public static Task <int> Main(string[] args)
{
var command = new RootCommand()
{
Description = "Developer tools and publishing for microservices.",
};
command.AddCommand(CreateInitCommand());
command.AddCommand(CreateGenerateCommand());
command.AddCommand(CreateRunCommand(args));
command.AddCommand(CreateBuildCommand());
command.AddCommand(CreateDeployCommand());
// Show commandline help unless a subcommand was used.
command.Handler = CommandHandler.Create <IHelpBuilder>(help =>
{
help.Write(command);
return(1);
});
var builder = new CommandLineBuilder(command);
builder.UseHelp();
builder.UseVersionOption();
builder.UseDebugDirective();
builder.UseParseErrorReporting();
builder.ParseResponseFileAs(ResponseFileHandling.ParseArgsAsSpaceSeparated);
builder.CancelOnProcessTermination();
builder.UseExceptionHandler(HandleException);
var parser = builder.Build();
return(parser.InvokeAsync(args));
}
public static async Task Can_have_diferent_handlers_based_on_command()
{
var root = new RootCommand();
root.AddCommand(new MyCommand());
root.AddCommand(new MyOtherCommand());
var parser = new CommandLineBuilder(root)
.UseHost(host =>
{
host.ConfigureServices(services =>
{
services.AddTransient <MyService>(_ => new MyService()
{
Action = () => 100
});
})
.UseCommandHandler <MyCommand, MyCommand.MyHandler>()
.UseCommandHandler <MyOtherCommand, MyOtherCommand.MyHandler>();
})
.Build();
var result = await parser.InvokeAsync(new string[] { "mycommand", "--int-option", "54" });
result.Should().Be(54);
result = await parser.InvokeAsync(new string[] { "myothercommand", "--int-option", "54" });
result.Should().Be(100);
}
private static int Main(string[] args)
{
System.Console.WriteLine("====================================================");
System.Console.WriteLine($"{SokoSolveApp.Name} :: v{SokoSolveApp.Version}");
System.Console.WriteLine(DevHelper.FullDevelopmentContext());
System.Console.WriteLine("----------------------------------------------------");
System.Console.WriteLine();
var root = new RootCommand();
root.AddCommand(BenchmarkCommand.GetCommand());
//------------------------------------------------------------------------------------------------------------
var play = new Command("play", "Play SokoSolve game in the console")
{
Handler = CommandHandler.Create(PlayCommand.Run)
};
root.AddCommand(play);
//------------------------------------------------------------------------------------------------------------
var micro = new Command("micro", "Micro Benchmarks (BenchmarkDotNet)")
{
new Argument <string>(() => "BaseLineSolvers")
{
Name = "target",
Description = "Target Type"
},
};
micro.Handler = CommandHandler.Create <string>(MicroCommand.Run);
root.AddCommand(micro);
//------------------------------------------------------------------------------------------------------------
return(root.Invoke(args));
}
static async Task Main(string[] args)
{
var cli = new RootCommand("Otc.Messaging.RabbitMQ.Cli");
SetupGlobalOptions(cli);
// Setup available commands
cli.AddCommand(CreateSimpleQueue.Setup());
cli.AddCommand(CreateMultipleQueues.Setup());
cli.AddCommand(CreateVirtualHost.Setup());
cli.AddCommand(ApplyMirrorPolicy.Setup());
// Parse command line arguments
var parsed = cli.Parse(args);
// Sets global options
Broker.Host = parsed.CommandResult.ValueForOption <string>("--host");
Broker.Port = parsed.CommandResult.ValueForOption <int>("--port");
Broker.ApiPort = parsed.CommandResult.ValueForOption <int>("--apiport");
Broker.User = parsed.CommandResult.ValueForOption <string>("--user");
Broker.Password = parsed.CommandResult.ValueForOption <string>("--pass");
Broker.VirtualHost = parsed.CommandResult.ValueForOption <string>("--vhost");
// Invoke execution
await cli.InvokeAsync(args);
}
public static void RegisterCommands(RootCommand rootCommand)
{
rootCommand.AddCommand(new Command("list-repo", "Lists current repositories")
{
Handler = CommandHandler.Create(ListRepo)
});
Command addRepo = new Command("add-repo", "Adds a repository")
{
new Option <string>(new[] { "--name", "-n" }, "The new repositories name")
{
Required = true
},
new Option <string>(new[] { "--link", "-l" }, "A link to the repositories XML")
{
Required = true
}
};
addRepo.Handler = CommandHandler.Create <string, string>(AddRepo);
rootCommand.AddCommand(addRepo);
Command removeRepo = new Command("remove-repo", "Removes a repository")
{
new Option <string>(new[] { "--name", "-n" }, "The repositories name")
{
Required = true
}
};
removeRepo.Handler = CommandHandler.Create <string>(RemoveRepo);
rootCommand.AddCommand(removeRepo);
}
private static RootCommand CreateCommandLineOptions()
{
// Root command and global options
RootCommand rootCommand = new RootCommand("Utility to automate iterative IO performance tests.");
// Path to the settings file must always be specified
rootCommand.AddOption(
new Option <string>("--settings")
{
Description = "Path to settings file.",
Required = true
});
// Write defaults to settings file
rootCommand.AddCommand(
new Command("writedefaults")
{
Description = "Write default values to settings file.",
Handler = CommandHandler.Create <string>(WriteDefaultsCommand)
});
// Run test
rootCommand.AddCommand(
new Command("runtests")
{
Description = "Run all tests.",
Handler = CommandHandler.Create <string>(RunTestsCommand)
});
return(rootCommand);
}
private static RootCommand CreateRootCommand()
{
var torrentOpt =
new Option <FileInfo>(
new[] { "--torrent", "-t" },
"The .torrent file to operate on"
)
{
IsRequired = true
};
var prog = new Program();
var rootCmd = new RootCommand("IOU torrent CLI");
var summaryCommand = new Command("summary", "Summarize torrent info");
summaryCommand.AddArgument(new Argument <FileInfo>("torrent"));
summaryCommand.Handler = CommandHandler.Create <FileInfo>(prog.SummarizeTorrent);
var dhtCommand = new Command("dht", "Dump DHT info");
dhtCommand.Handler = CommandHandler.Create(async() => {
var ip = await AskPublicIpAddressAsync();
Console.WriteLine($"IP: {ip}");
});
rootCmd.AddCommand(new TorrentCommand());
rootCmd.AddCommand(dhtCommand);
return(rootCmd);
}
public static void Main(string[] args)
{
var fhirServerOption = new Option(
OptionAliases.FhirServer,
Resources.FhirServerOptionDescription,
new Argument <Uri> {
Arity = ArgumentArity.ExactlyOne
});
var connectionStringOption = new Option(
OptionAliases.ConnectionString,
Resources.ConnectionStringOptionDescription,
new Argument <string> {
Arity = ArgumentArity.ExactlyOne
});
var versionOption = new Option(
OptionAliases.Version,
Resources.VersionOptionDescription,
new Argument <int> {
Arity = ArgumentArity.ExactlyOne
});
var rootCommand = new RootCommand();
var currentCommand = new Command(CommandNames.Current, Resources.CurrentCommandDescription)
{
fhirServerOption,
};
currentCommand.Handler = CommandHandler.Create <Uri>(CurrentCommand.Handler);
currentCommand.Argument.AddValidator(symbol => Validators.RequiredOptionValidator.Validate(symbol, fhirServerOption, Resources.FhirServerRequiredValidation));
var applyCommand = new Command(CommandNames.Apply, Resources.ApplyCommandDescription)
{
connectionStringOption,
fhirServerOption,
versionOption,
};
applyCommand.Handler = CommandHandler.Create <string, Uri, int>(ApplyCommand.Handler);
applyCommand.Argument.AddValidator(symbol => Validators.RequiredOptionValidator.Validate(symbol, connectionStringOption, Resources.ConnectionStringRequiredValidation));
applyCommand.Argument.AddValidator(symbol => Validators.RequiredOptionValidator.Validate(symbol, fhirServerOption, Resources.FhirServerRequiredValidation));
applyCommand.Argument.AddValidator(symbol => Validators.RequiredOptionValidator.Validate(symbol, versionOption, Resources.VersionRequiredValidation));
var availableCommand = new Command(CommandNames.Available, Resources.AvailableCommandDescription)
{
fhirServerOption,
};
availableCommand.Handler = CommandHandler.Create <InvocationContext, Uri>(AvailableCommand.Handler);
availableCommand.Argument.AddValidator(symbol => Validators.RequiredOptionValidator.Validate(symbol, fhirServerOption, Resources.FhirServerRequiredValidation));
rootCommand.AddCommand(applyCommand);
rootCommand.AddCommand(availableCommand);
rootCommand.AddCommand(currentCommand);
rootCommand.InvokeAsync(args).Wait();
}
private static CommandLineBuilder BuildCommandLine()
{
var root = new RootCommand();
root.AddCommand(IndexCommand.Create());
root.AddCommand(SearchCommand.Create());
return(new CommandLineBuilder(root));
}
static int Main(string[] args)
{
var rootCommand = new RootCommand();
rootCommand.AddCommand(CreateServiceCommand.Create());
rootCommand.AddCommand(CreateSocketCommand.Create());
return(rootCommand.InvokeAsync(args).Result);
}
static async Task <int> Main(string[] args)
{
var cmd = new RootCommand();
cmd.AddCommand(Helloworld());
cmd.AddCommand(SalutaConNome());
return(await cmd.InvokeAsync(args));
}
static async Task <int> Main(string[] args)
{
var rootCommand = new RootCommand();
rootCommand.AddCommand(GetEncryptCommand());
rootCommand.AddCommand(GetDecryptCommand());
return(await rootCommand.InvokeAsync(args).ConfigureAwait(false));
}
public Parser Create(
EnvironmentInit environmentInit = null,
NewFile newFile = null,
PluginInstall pluginInstall = null,
PluginUninstall pluginUninstall = null,
PluginList pluginList = null,
SetUsername setEnvironmentSetting = null,
TemplateInstall templateInstall = null,
TemplateUninstall templateUninstall = null)
{
// if environmentInit hasn't been provided (for testing) then assign the Command Handler
environmentInit ??= EnvironmentInitHandler.ExecuteAsync;
newFile ??= NewFileHandler.ExecuteAsync;
pluginInstall ??= PluginInstallHandler.ExecuteAsync;
pluginUninstall ??= PluginUninstallHandler.ExecuteAsync;
pluginList ??= PluginListHandler.ExecuteAsync;
setEnvironmentSetting ??= SetEnvironmentSettingHandler.ExecuteAsync;
templateInstall ??= TemplatePackageInstallerHandler.ExecuteAsync;
templateUninstall ??= TemplatePackageUninstallerHandler.ExecuteAsync;
// Set up intrinsic commands that will always be available.
RootCommand rootCommand = Root();
rootCommand.AddCommand(Environment());
rootCommand.AddCommand(NewFile());
rootCommand.AddCommand(Plugins());
rootCommand.AddCommand(Templates());
var commandBuilder = new CommandLineBuilder(rootCommand);
try
{
foreach (Command command in this.commandPluginHost.Discover(this.appEnvironment.PluginPaths))
{
commandBuilder.AddCommand(command);
}
}
catch (DirectoryNotFoundException)
{
// If this is the first run, initialize the environment and default plugins
Console.WriteLine("Error Detected: vellum environment uninitialized.");
Parser parser = commandBuilder.UseDefaults().Build();
int result = parser.Invoke("environment init");
if (result == ReturnCodes.Ok)
{
// Now the environment has been re-initialized, try to discover the plugins again.
foreach (Command command in this.commandPluginHost.Discover(this.appEnvironment.PluginPaths))
{
commandBuilder.AddCommand(command);
}
}
}
return(commandBuilder.UseDefaults().Build());
public override Command Configure()
{
RootCommand res = new RootCommand(Program.AppDescription);
res.AddCommand(new ConfigCommand().Build());
res.AddCommand(new ExtensionCommand().Build());
res.AddCommand(new CommandCommand().Build());
res.AddCommand(new WorkspaceCommand().Build());
return(res);
}
static CommandLineConfigs()
{
DryRunCommand.AddAlias(WhatIfCommandName);
UninstallRootCommand.AddCommand(ListCommand);
UninstallRootCommand.AddCommand(DryRunCommand);
UninstallRootCommand.AddCommand(RemoveCommand);
var supportedBundleTypeNames = SupportedBundleTypeConfigs.GetSupportedBundleTypes().Select(type => type.OptionName);
RemoveAuxOptions = UninstallBundleTypeOptions
.Where(option => supportedBundleTypeNames.Contains(option.Name))
.Concat(AdditionalUninstallOptions)
.Append(YesOption);
if (RuntimeInfo.RunningOnWindows)
{
RemoveAuxOptions = RemoveAuxOptions.Concat(ArchUninstallOptions);
}
AssignOptionsToCommand(RemoveCommand, RemoveAuxOptions
.Concat(UninstallFilterBundlesOptions), true);
DryRunAuxOptions = UninstallBundleTypeOptions
.Where(option => supportedBundleTypeNames.Contains(option.Name))
.Concat(AdditionalUninstallOptions);
if (RuntimeInfo.RunningOnWindows)
{
DryRunAuxOptions = DryRunAuxOptions.Concat(ArchUninstallOptions);
}
AssignOptionsToCommand(DryRunCommand, DryRunAuxOptions
.Concat(UninstallFilterBundlesOptions), true);
ListAuxOptions = ListBundleTypeOptions
.Where(option => supportedBundleTypeNames.Contains(option.Name))
.Append(VerbosityOption);
if (RuntimeInfo.RunningOnWindows)
{
ListAuxOptions = ListAuxOptions
.Append(ListX64Option)
.Append(ListX86Option);
}
AssignOptionsToCommand(ListCommand, ListAuxOptions);
var bundleCollector = RuntimeInfo.RunningOnWindows ? new RegistryQuery() as IBundleCollector : new FileSystemExplorer() as IBundleCollector;
ListCommand.Handler = CommandHandler.Create(ExceptionHandler.HandleException(() => ListCommandExec.Execute(bundleCollector)));
DryRunCommand.Handler = CommandHandler.Create(ExceptionHandler.HandleException(() => DryRunCommandExec.Execute(bundleCollector)));
RemoveCommand.Handler = CommandHandler.Create(ExceptionHandler.HandleException(() => UninstallCommandExec.Execute(bundleCollector)));
UninstallCommandParser = new CommandLineBuilder(UninstallRootCommand)
.UseDefaults()
.UseVersionOption()
.UseHelpBuilder(context => new UninstallHelpBuilder(context.Console))
.Build();
CommandLineParseResult = UninstallCommandParser.Parse(Environment.GetCommandLineArgs());
}
internal static RootCommand CreateRootCommand()
{
var root = new RootCommand("JSON .NET Global Tool");
root.AddCommand(new MergeCommand());
root.AddCommand(new SetCommand());
root.AddCommand(new RemoveCommand());
root.AddCommand(new GetCommand());
return(root);
}
/// <summary>
/// I2C EEPROM programmer with Arduino HW interface
/// </summary>
static void Main(string[] args)
{
var rootCommand = new RootCommand();
rootCommand.AddCommand(new Identify());
rootCommand.AddCommand(new ListSerialPorts());
rootCommand.AddCommand(new ScanI2CDevices());
rootCommand.AddCommand(new ReadToFile());
rootCommand.AddCommand(new WriteFromFile());
rootCommand.InvokeAsync(args).Wait();
}
static int Main(string[] args)
{
var rootCommand = new RootCommand();
var showCommand = GetShowCommand();
var syncCommand = GetSyncCommand();
rootCommand.AddCommand(showCommand);
rootCommand.AddCommand(syncCommand);
return(rootCommand.InvokeAsync(args).Result);
}
private static int Main(string[] args)
{
var rootCommand = new RootCommand("The Coyote documentation generator.");
var generateCommand = CreateGenerateCommand();
var mergeCommand = CreateMergeCommand();
rootCommand.AddCommand(generateCommand);
rootCommand.AddCommand(mergeCommand);
rootCommand.TreatUnmatchedTokensAsErrors = true;
return(rootCommand.Invoke(args));
}
static int Main(string[] args)
{
if (args.Length > 0)
{
AttachConsole(AttachParentProcess);
}
var command = new RootCommand
{
Handler = CommandHandler.Create(() =>
{
Run(new SdkWrapperProxy(new SdkWrapper(), record: false));
})
};
Command record = new Command(
name: "record",
description: "Record session updates and telemetry.")
{
Handler = CommandHandler.Create(() =>
{
Run(new SdkWrapperProxy(new SdkWrapper(), record: true));
})
};
command.AddCommand(record);
Command playback = new Command(
name: "playback",
description: "Play back only events from the indexed session within the session log.")
{
new Argument <string>(
name: "logfile",
description: "The RaceAdmin session log file to play back."),
new Option(
aliases: new[] { "--session", "-s" },
description: "Play back only events from the indexed session within the session log.")
{
Argument = new Argument <int>(getDefaultValue: () => - 1)
}
};
playback.Handler = CommandHandler.Create((string logfile, int session) =>
{
// for now assume just a filename and look for file in documents folder
string documentsPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
BinaryReader reader = new BinaryReader(File.Open(documentsPath + "\\" + logfile, FileMode.Open));
Run(new SdkReplayProxy(reader, session));
});
command.AddCommand(playback);
return(command.Invoke(args));
}
static Task <int> Main(string[] args)
{
var rootCommand = new RootCommand
{
Description = "V-Drum Explorer console interface"
};
rootCommand.AddCommand(ListDevicesCommand.Command);
rootCommand.AddCommand(ImportKitCommand.Command);
rootCommand.AddCommand(ShowKitCommand.Command);
return(rootCommand.InvokeAsync(args));
}
public static int Main(string[] args)
{
var rootCommand = new RootCommand();
var qtCommand = new Command(
"--order-templates",
description: "Order question templates"
);
qtCommand.AddAlias("-ot");
qtCommand.AddArgument(new Argument <string>("question-file"));
qtCommand.Handler = CommandHandler.Create <string>((questionFile) =>
{
Console.WriteLine("Ordering question templates");
DbHandler dbHandler = new DbHandler();
dbHandler.OrderQuestionTemplates(questionFile);
});
rootCommand.AddCommand(qtCommand);
var qfCommand = new Command(
"--templates",
description: "JSON-file with questions"
);
qfCommand.AddAlias("-t");
qfCommand.AddArgument(new Argument <string>("question-file"));
qfCommand.Handler = CommandHandler.Create <string>((questionFile) =>
{
Console.WriteLine($"The given input is: {questionFile}");
DbHandler dbHandler = new DbHandler();
dbHandler.PopulateQuestionTemplate(questionFile);
});
rootCommand.AddCommand(qfCommand);
var oqCommand = new Command(
"--order-questions",
description: "Order questions in given evaluation"
);
oqCommand.AddAlias("-oq");
oqCommand.AddArgument(new Argument <string>("evaluation-id"));
oqCommand.Handler = CommandHandler.Create <string>((evaluationId) =>
{
Console.WriteLine($"Ordering questions for evaluation: {evaluationId}");
DbHandler dbHandler = new DbHandler();
dbHandler.OrderQuestionsInEvaluation(evaluationId);
});
rootCommand.AddCommand(oqCommand);
rootCommand.Description = "Various scripts for DB handling";
return(rootCommand.InvokeAsync(args).Result);
}
public static int Run(string[] args)
{
var rootCommand = new RootCommand();
rootCommand.Add(new Option <VerbosityLevel>("--verbosity", VerbosityLevel.Normal, "Output verbosity level. Allowed values are normal and diagnostic."));
rootCommand.Add(new Option <string[]>("--trace", Array.Empty <string>(), "Output additional trace loggers specified by name."));
var buildCommand = new Command("build", "Generates C# code, database model file and other project assets.");
// CurrentDirectory by default, because rhetos.exe on *build* is expected to be located in NuGet package cache.
buildCommand.Add(new Argument <DirectoryInfo>("project-root-folder", () => new DirectoryInfo(Environment.CurrentDirectory))
{
Description = "Project folder where csproj file is located. If not specified, current working directory is used by default."
});
buildCommand.Add(new Option <bool>("--msbuild-format", false, "Adjust error output format for MSBuild integration."));
buildCommand.Handler = CommandHandler.Create((DirectoryInfo projectRootFolder, bool msbuildFormat, VerbosityLevel verbosity, string[] trace) =>
{
var program = new Program(verbosity, trace);
program.SafeExecuteCommand(() => program.Build(projectRootFolder.FullName), "Build", msbuildFormat);
});
rootCommand.AddCommand(buildCommand);
var dbUpdateCommand = new Command("dbupdate", "Updates the database structure and initializes the application data in the database.");
dbUpdateCommand.Add(new Argument <FileInfo>("startup-assembly")
{
Description = "Startup assembly of the host application."
});
dbUpdateCommand.Add(new Option <bool>("--short-transactions", "Commit transaction after creating or dropping each database object."));
dbUpdateCommand.Add(new Option <bool>("--skip-recompute", "Skip automatic update of computed data with KeepSynchronized. See output log for data that needs updating."));
//Lack of this switch means that the dbupdate command should start the command rhetos.exe dbupdate
//in another process with the host applications runtimeconfig.json and deps.json files
var executeCommandInCurrentProcessOption = new Option <bool>(ExecuteCommandInCurrentProcessOptionName);
executeCommandInCurrentProcessOption.IsHidden = true;
dbUpdateCommand.Add(executeCommandInCurrentProcessOption);
dbUpdateCommand.Handler =
CommandHandler.Create((FileInfo startupAssembly, bool shortTransactions, bool skipRecompute, bool executeCommandInCurrentProcess, VerbosityLevel verbosity, string[] trace) =>
{
var program = new Program(verbosity, trace);
if (executeCommandInCurrentProcess)
{
return(program.SafeExecuteCommand(() => program.DbUpdate(startupAssembly.FullName, shortTransactions, skipRecompute), "DbUpdate", msBuildErrorFormat: false));
}
else
{
return(program.InvokeDbUpdateAsExternalProcess(startupAssembly.FullName, args));
}
});
rootCommand.AddCommand(dbUpdateCommand);
return(rootCommand.Invoke(args));
}