public override CommandInput GenerateRandomInput(string keyword)
{
var toReturn = new CommandInput();
toReturn.Keyword = keyword;
var i = 0;
foreach (var part in Parts)
{
toReturn.Parameters.Add(new Parameter { Value = part.GenerateInput(), Index = i++ });
}
return toReturn;
}
void Update()
{
if (Input.GetKeyDown(KeyCode.F1))
{
DisplayPanel.SetActive(!DisplayPanel.activeInHierarchy);
ConsoleOpen = DisplayPanel.activeInHierarchy;
if (ConsoleOpen)
{
CommandInput.ActivateInputField();
CommandInput.Select();
}
}
}
public virtual bool TryRun(CommandInput ci, IOutput output, out IList<CommandError> errors)
{
errors = new List<CommandError>();
foreach (var sig in this.Signatures)
{
if (sig.CanRun(ci))
{
return sig.Run(ci, errors);
}
}
errors.Add(new CommandError("Unknown parameters", "Current parameters can't be parsed"));
return false;
}
public void Positive_ReadSingleIndexParameter()
{
var keyword = "keyword";
var parameterValue = "value";
var line = $"{keyword} {parameterValue}";
var result = CommandInput.Parse(line);
Assert.IsNotNull(result);
Assert.AreEqual(keyword, result.Keyword);
Assert.IsNotNull(result.Parameters);
Assert.AreEqual(1, result.Parameters.Count);
Assert.IsFalse(result.Parameters[0].IsNamed);
Assert.AreEqual(parameterValue, result.Parameters[0].Value);
}
public virtual bool TryRun(CommandInput ci, IOutput output, out IList <CommandError> errors)
{
errors = new List <CommandError>();
foreach (var sig in this.Signatures)
{
if (sig.CanRun(ci))
{
return(sig.Run(ci, errors));
}
}
errors.Add(new CommandError("Unknown parameters", "Current parameters can't be parsed"));
return(false);
}
public CommandOutput OnExecute(CommandInput arguments)
{
var output = new CommandOutput {
PostAction = CommandOutput.PostCommandAction.None
};
long suiteId = long.Parse(arguments["sid"]);
long userId = arguments.GetUserId();
List <MappingModel> listOfMaps = CurrentHostContext.Default.Provider.ConfigurationStore.GetMapping(userId,
suiteId);
output.Data = listOfMaps;
output.DisplayMessage = "Success";
return(output);
}
public CommandOutput OnExecute(CommandInput arguments)
{
var output = new CommandOutput {
PostAction = CommandOutput.PostCommandAction.None
};
long suiteId = -1;
long userId = arguments.GetUserId();
long.TryParse(arguments["sid"], out suiteId);
var model = CurrentHostContext.Default.Provider.ConfigurationStore.GetRegions(userId, suiteId);
output.Data = model;
output.DisplayMessage = "Success";
return(output);
}
public void GetTargetCommandSchema_Positive_Test(IReadOnlyList <CommandSchema> availableCommandSchemas,
CommandInput commandInput,
IReadOnlyList <string> expectedPositionalArguments,
string expectedCommandSchemaName)
{
// Arrange
var resolver = new CommandSchemaResolver(new CommandArgumentSchemasValidator());
// Act
var commandCandidate = resolver.GetTargetCommandSchema(availableCommandSchemas, commandInput);
// Assert
commandCandidate.Should().NotBeNull();
commandCandidate.PositionalArgumentsInput.Should().BeEquivalentTo(expectedPositionalArguments);
commandCandidate.Schema.Name.Should().Be(expectedCommandSchemaName);
}
public override void Dispatch(CommandInput e)
{
#if DEBUG_VERBOSE
// DEBUG_VERBOSE because these serve almost no practical purpose when debugging
("Dispatch(" + _displayName + ") " + Convert.ToString(e)).Log();
#endif
ServerTxPerformanceIncrement("CMD");
try
{
Send(e);
}
catch
{
Control.Network.Server.RemoveClient(this);
}
}
public bool Run()
{
if (!IsValid)
{
return(false);
}
CommandInput commands = GetCommandInput();
foreach (ArticulationJoint joint in _joints)
{
joint.ApplyCommand(commands);
}
return(true);
}
public void Positive_ReadSingleSwitchParameters()
{
var keyword = "keyword";
var parameter1Name = "name";
var line = $"{keyword} -{parameter1Name}";
var result = CommandInput.Parse(line);
Assert.IsNotNull(result);
Assert.AreEqual(keyword, result.Keyword);
Assert.IsNotNull(result.Parameters);
Assert.AreEqual(1, result.Parameters.Count);
Assert.IsTrue(result.Parameters[0].IsNamed);
Assert.AreEqual(null, result.Parameters[0].Value);
}
private void WriteCommandLineInput(CommandInput input)
{
// Command name
if (!string.IsNullOrWhiteSpace(input.CommandName))
{
_console.WithForegroundColor(ConsoleColor.Cyan, () =>
_console.Output.Write(input.CommandName));
_console.Output.Write(' ');
}
// Parameters
foreach (var parameter in input.Parameters)
{
_console.Output.Write('<');
_console.WithForegroundColor(ConsoleColor.White, () =>
_console.Output.Write(parameter));
_console.Output.Write('>');
_console.Output.Write(' ');
}
// Options
foreach (var option in input.Options)
{
_console.Output.Write('[');
_console.WithForegroundColor(ConsoleColor.White, () =>
{
// Alias
_console.Output.Write(option.GetRawAlias());
// Values
if (option.Values.Any())
{
_console.Output.Write(' ');
_console.Output.Write(option.GetRawValues());
}
});
_console.Output.Write(']');
_console.Output.Write(' ');
}
_console.Output.WriteLine();
}
private int?HandleHelpOption(CommandInput commandInput,
IReadOnlyList <CommandSchema> availableCommandSchemas, CommandSchema targetCommandSchema)
{
// Help should be rendered if it was requested, or when executing a command which isn't defined
var shouldRenderHelp = commandInput.IsHelpOptionSpecified() || targetCommandSchema == null;
// If shouldn't render help, pass execution to the next handler
if (!shouldRenderHelp)
{
return(null);
}
// Keep track whether there was an error in the input
var isError = false;
// If target command isn't defined, find its contextual replacement
if (targetCommandSchema == null)
{
// If command was specified, inform the user that it's not defined
if (commandInput.IsCommandSpecified())
{
_console.WithForegroundColor(ConsoleColor.Red,
() => _console.Error.WriteLine($"Specified command [{commandInput.CommandName}] is not defined."));
isError = true;
}
// Replace target command with closest parent of specified command
targetCommandSchema = availableCommandSchemas.FindParent(commandInput.CommandName);
// If there's no parent, replace with stub default command
if (targetCommandSchema == null)
{
targetCommandSchema = CommandSchema.StubDefaultCommand;
availableCommandSchemas = availableCommandSchemas.Concat(CommandSchema.StubDefaultCommand).ToArray();
}
}
// Build help text source
var helpTextSource = new HelpTextSource(_metadata, availableCommandSchemas, targetCommandSchema);
// Render help text
_helpTextRenderer.RenderHelpText(_console, helpTextSource);
// Short-circuit with appropriate exit code
return(isError ? -1 : 0);
}
/// <inheritdoc/>
public async Task <int> ExecuteCommandAsync(IEnumerable <string> commandLineArguments)
{
_logger.LogInformation("Executing command '{CommandLineArguments}'.", commandLineArguments);
using (IServiceScope serviceScope = _serviceScopeFactory.CreateScope())
{
IServiceProvider provider = serviceScope.ServiceProvider;
ICliContext cliContext = provider.GetRequiredService <ICliContext>();
Guid cliContextId = cliContext.Id;
_logger.LogDebug("New scope created with CliContext {CliContextId}.", cliContextId);
CommandInput input = CommandInputResolver.Parse(commandLineArguments, _rootSchemaAccessor.RootSchema.GetCommandNames());
((CliContext)cliContext).Input = input;
try
{
// Execute middleware pipeline
await RunPipelineAsync(provider, cliContext);
}
catch (Exception ex)
{
_logger.LogDebug("Exception occured. Trying to find exception handler.");
IEnumerable <ICliExceptionHandler> exceptionHandlers = provider.GetServices <ICliExceptionHandler>();
foreach (ICliExceptionHandler handler in exceptionHandlers)
{
if (handler.HandleException(ex))
{
_logger.LogDebug(ex, "Exception handled by {ExceptionHandlerType}.", handler.GetType().FullName);
return(ExitCodes.FromException(ex));
}
}
_logger.LogCritical(ex, "Unhandled exception during command execution.");
throw;
}
finally
{
_logger.LogDebug("Disposed scope with CliContext {CliContextId}.", cliContextId);
}
return(cliContext.ExitCode ?? ExitCodes.Error);
}
}
private int?HandleVersionOption(CommandInput commandInput)
{
// Version should be rendered if it was requested on a default command
var shouldRenderVersion = !commandInput.IsCommandSpecified() && commandInput.IsVersionOptionSpecified();
// If shouldn't render version, pass execution to the next handler
if (!shouldRenderVersion)
{
return(null);
}
// Render version text
_console.Output.WriteLine(_metadata.VersionText);
// Short-circuit with exit code 0
return(0);
}
public void Test_RobotCommandFactory_ProvideCommandInput_RelatedCommandIsReturned()
{
var input = new CommandInput("S", 2);
var southCommand = RobotCommandProvider.GetCommand(input, new RobotPositioningContext());
Assert.AreEqual(typeof(MoveSouthCommand), southCommand.GetType());
var input2 = new CommandInput("E", 2);
var eastCommand = RobotCommandProvider.GetCommand(input2, new RobotPositioningContext());
Assert.AreEqual(typeof(MoveEastCommand), eastCommand.GetType());
var input3 = new CommandInput("N", 4);
var northCommand = RobotCommandProvider.GetCommand(input3, new RobotPositioningContext());
Assert.AreEqual(typeof(MoveNorthCommand), northCommand.GetType());
}
private int?Execute(CliContext context)
{
CommandInput input = context.Input;
// Get command schema from context
CommandSchema commandSchema = context.CommandSchema;
// Version option
if (commandSchema.IsVersionOptionAvailable && input.IsVersionOptionSpecified)
{
context.Console.Output.WriteLine(context.Metadata.VersionText);
return(ExitCodes.Success);
}
return(null);
}
private void SendInput(object sender, RoutedEventArgs e)
{
try
{
if (CommandInput.Text.ToString() == "q" && serverRunning)
{
_heartbeat.Stop();
serverRunning = false;
StopServerBtn.IsEnabled = false;
StartServerBtn.IsEnabled = true;
}
ServerConsole.StandardInput.WriteLine(CommandInput.Text);
ConsoleText.Text += CommandInput.Text + "\r\n";
CommandInput.Clear();
}
catch { }
}
private void WriteCommandLineArguments(CommandInput commandInput)
{
Write("Command line:");
WriteLine();
WriteHorizontalMargin();
// Command name
if (!string.IsNullOrWhiteSpace(commandInput.CommandName))
{
Write(ConsoleColor.Cyan, commandInput.CommandName);
Write(' ');
}
// Parameters
foreach (var parameterInput in commandInput.Parameters)
{
Write('<');
Write(ConsoleColor.White, parameterInput.Value);
Write('>');
Write(' ');
}
// Options
foreach (var optionInput in commandInput.Options)
{
Write('[');
// Identifier
Write(ConsoleColor.White, optionInput.GetFormattedIdentifier());
// Value(s)
foreach (var value in optionInput.Values)
{
Write(' ');
Write('"');
Write(value);
Write('"');
}
Write(']');
Write(' ');
}
WriteLine();
}
public override CommandInput GenerateRandomInput(string keyword)
{
var toReturn = new CommandInput();
toReturn.Keyword = keyword;
var i = 0;
foreach (var part in Parts)
{
toReturn.Parameters.Add(new Parameter {
Value = part.GenerateInput(), Index = i++
});
}
return(toReturn);
}
public CommandOutput OnExecute(CommandInput arguments)
{
var output = new CommandOutput {
PostAction = CommandOutput.PostCommandAction.None
};
var suiteId = long.Parse(arguments["sid"]);
long userId = arguments.GetUserId();
var success = CurrentHostContext.Default.Provider.ConfigurationStore.DeleteSuite(new SuiteModel
{
UserId = userId,
SuiteId = suiteId
});
output.DisplayMessage = success ? "Suite deleted successfully!" : "Could not delete suite";
return(output);
}
private void CommandInput_KeyDown(object sender, KeyEventArgs e)
{
if (e.Key != Key.Enter)
{
return;
}
if (CommandInput.Text.ToString() == "q" && serverRunning)
{
_heartbeat.Stop();
serverRunning = false;
StopServerBtn.IsEnabled = false;
StartServerBtn.IsEnabled = true;
ServerConsole.StandardInput.WriteLine(CommandInput.Text);
ConsoleText.Text += CommandInput.Text + "\r\n";
}
CommandInput.Clear();
}
public CommandOutput OnExecute(CommandInput arguments)
{
var output = new CommandOutput {
PostAction = CommandOutput.PostCommandAction.None
};
bool completed = false;
SuiteModel model = default(SuiteModel);
long userId = arguments.GetUserId();
if (arguments["name"] != null)
{
model = CurrentHostContext.Default.Provider.ConfigurationStore.GetSuite(userId, arguments["name"]);
completed = true;
}
else if (arguments["id"] != null)
{
long suiteId = -1;
long.TryParse(arguments["id"], out suiteId);
if (suiteId != -1)
{
model = CurrentHostContext.Default.Provider.ConfigurationStore.GetSuite(userId, suiteId);
completed = true;
}
}
if (!completed)
{
output.DisplayMessage = "Invalid data in command received";
output.PostAction = CommandOutput.PostCommandAction.ShowCommandHelp;
output.MessageType = CommandOutput.DisplayMessageType.Error;
}
else if (model != null)
{
output.Data = model;
output.DisplayMessage = "Success";
}
else
{
output.DisplayMessage = DoesNotExist;
output.MessageType = CommandOutput.DisplayMessageType.Error;
}
return(output);
}
private void OnListViewKeyUp(object sender, KeyEventArgs e)
{
var listview = e.Source as ListView;
if (e.Key == Key.Enter)
{
ViewModel.Send();
}
if (e.Key == Key.Escape)
{
CommandInput.Focus();
}
if (e.KeyboardDevice.Modifiers.HasFlag(ModifierKeys.Control))
{
if (e.Key == Key.C)
{
var text = String.Join("\r\n", listview.SelectedItems.Cast <Object>());
Clipboard.SetText(text);
}
if (e.Key == Key.V)
{
ViewModel.Send(Clipboard.GetText());
}
if (e.Key == Key.M)
{
MeasureAverage(listview);
return;
}
if (e.Key == Key.T)
{
RebaseSelected(listview);
}
//if (e.Key == Key.V)
//{
// Clipboard.GetText().Split(new[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
// ViewModel.Send();
//}
}
}
public List <StreamIdentifier> Add(CommandInput resource)
{
if (resource == null)
{
throw new ArgumentNullException("resource");
}
resource.Owner = Owner;
if (Owner.Objects.ContainsInput(resource))
{
throw new ArgumentException("Command already contains the specified resource.", "resource");
}
Owner.Objects.Inputs.Add(resource);
return(resource.GetStreamIdentifiers());
}
private void ExecuteCommand()
{
if (CommandInput.Text.Length == 0)
{
return; // prevent empty commands
}
if (CommandInput.Text.ToUpper().Equals("EXIT"))
{
Application.Current.Shutdown();
}
else
{
listener.SendCommand(CommandInput.Text);
}
CommandLog.AppendText("> " + CommandInput.Text + "\r\n");
CommandInput.Clear();
}
public List<StreamIdentifier> Insert(int index, CommandInput resource)
{
if (resource == null)
{
throw new ArgumentNullException("resource");
}
resource.Owner = Owner;
if (Owner.Objects.ContainsInput(resource))
{
throw new ArgumentException("Command already contains the specified resource.", "resource");
}
Owner.Objects.Inputs.Insert(index, resource);
return resource.GetStreamIdentifiers();
}
private int?Execute(CliContext context)
{
// Get input and command schema from context
CommandInput input = context.Input;
CommandSchema commandSchema = context.CommandSchema;
// Help option
if ((commandSchema.IsHelpOptionAvailable && input.IsHelpOptionSpecified) ||
(commandSchema == StubDefaultCommand.Schema && !input.Parameters.Any() && !input.Options.Any()))
{
IHelpWriter helpTextWriter = new DefaultHelpWriter(context);
helpTextWriter.Write(commandSchema, context.CommandDefaultValues);
return(ExitCodes.Success);
}
return(null);
}
public CommandOutput OnExecute(CommandInput arguments)
{
var output = new CommandOutput {
PostAction = CommandOutput.PostCommandAction.None
};
long suiteId = long.Parse(arguments["sid"]);
string username = arguments["user"];
long loggedInUserId = arguments.GetUserId();
RoleType role = arguments.HasArgument("role") ? arguments["role"].ToEnum <RoleType>() : RoleType.ReadOnly;
bool success = CurrentHostContext.Default.Provider.ConfigurationStore.GrantRoleAccessToSuite(suiteId,
loggedInUserId,
username, role);
output.Data = success;
output.DisplayMessage = success
? "Grants added successfully"
: "Some problem occured while granting rights to user";
return(output);
}
public CommandOutput OnExecute(CommandInput arguments)
{
var output = new CommandOutput {
PostAction = CommandOutput.PostCommandAction.None
};
long suiteId = long.Parse(arguments["sid"]);
string username = arguments["user"];
long loggedInUserId = arguments.GetUserId();
bool success = CurrentHostContext.Default.Provider.ConfigurationStore.RevokeRoleAccessToSuite(suiteId,
loggedInUserId, username);
output.Data = success;
output.DisplayMessage = success
? "Grants revoked successfully"
: "Some problem occured while revoking rights from user";
return(output);
}
public void ApplyCommand(CommandInput commands)
{
float response = GetResponse(commands);
if (joint_type == ArticulationType.piston)
{
IMyPistonBase piston = (IMyPistonBase)joint; //should throw exception if this does not work
piston.Velocity = response;
return;
}
if (joint_type == ArticulationType.rotor)
{
IMyMotorStator rotor = (IMyMotorStator)joint; //should throw exception if this does not work
rotor.TargetVelocityRPM = response;
return;
}
throw new Exception($"Error in CommandGroup.ApplyCommandResponse: Unrecognized joint type: {joint_type.ToString()}");
}
public CommandOutput OnExecute(CommandInput arguments)
{
var output = new CommandOutput {
PostAction = CommandOutput.PostCommandAction.None
};
var name = arguments["name"];
long suiteId = long.Parse(arguments["sid"]);
var value = arguments["val"];
var isEncrypted = arguments.HasArgument("protect");
long userId = arguments.GetUserId();
if (isEncrypted)
{
var suite = CurrentHostContext.Default.Provider.ConfigurationStore.GetSuite(userId, suiteId);
if (suite != null)
{
value = EncryptionEngine.Default.Encrypt(value, suite.PublicKey, null);
}
else
{
output.DisplayMessage = "Could not retrieve suite :" + suiteId;
output.MessageType = CommandOutput.DisplayMessageType.Error;
output.PostAction = CommandOutput.PostCommandAction.ShowCommandHelp;
return(output);
}
}
var parameter = CurrentHostContext.Default.Provider.ConfigurationStore.AddParameter(new ParameterModel
{
ParameterName = name,
ParameterValue = string.IsNullOrEmpty(value) ? string.Empty : value,
IsActive = true,
IsEncrypted = isEncrypted,
SuiteId = suiteId,
UserId = userId
});
output.Data = parameter;
output.DisplayMessage = "Success";
return(output);
}
//read function
public void GetInput()
{
ListMessages.Add(CommandInput);
List <string> listOfParams = new List <string>();
listOfParams = CommandInput.Split(' ').ToList();
if (listOfParams[0] == "depend")
{
CommandInput = "";
Messages = "Adding Dependencies";
AddDependency(listOfParams);
}
else if (listOfParams[0] == "install")
{
CommandInput = "";
Messages = "";
InstallComponent(listOfParams[1]);
}
else if (listOfParams[0] == "remove")
{
CommandInput = "";
Messages = "";
RemoveComponent(listOfParams[1]);
}
else if (listOfParams[0] == "list")
{
CommandInput = "";
Messages = "Displaying list of installed Components";
ListInstalledComponents();
}
else if (listOfParams[0] == "end")
{
Messages = "Ending Component Installation";
}
else
{
Messages = "No command detected, no action taken";
}
OutputList = ListMessages;
}
public override bool CanRun(CommandInput ci)
{
if (ci.Keyword != Keyword)
{
return false;
}
if (ci.IndexParameters.Count != this.ParameterCount)
{
return false;
}
for (var i = 0; i < ci.IndexParameters.Count; i++)
{
if (!this.Parts[i].CanParse(ci.IndexParameters[i]))
{
return false;
}
}
return true;
}
public override bool Run(CommandInput ci, IList<CommandError> errors)
{
return this._callback?.Invoke(ci, errors) ?? false;
}
private void WriteResourcePreSettings(CommandInput resource)
{
if (resource == null)
{
throw new ArgumentNullException("resource");
}
resource.Settings.SettingsList.ForEach(setting =>
{
if (!setting.IsPreSetting()) return;
BuilderBase.Append(" ");
BuilderBase.Append(SettingSerializer.Serialize(setting));
});
}
private void WriteResource(CommandInput resource)
{
if (resource == null)
{
throw new ArgumentNullException("resource");
}
WriteResourcePreSettings(resource);
var inputResource = new Input(resource.Resource);
BuilderBase.Append(" ");
BuilderBase.Append(SettingSerializer.Serialize(inputResource));
WriteResourcePostSettings(resource);
}
public bool ContainsInput(CommandInput commandInput)
{
return Inputs.Any(input => input.Id == commandInput.Id);
}
public static MetadataInfoStreamCalculator Create(CommandInput commandResource)
{
var infoStreamItem = MetadataInfoTreeSource.Create(commandResource);
return new MetadataInfoStreamCalculator(infoStreamItem);
}
private void WriteResourcePreSettings(CommandInput resource, Dictionary<Type, SettingsApplicationData> settingsData)
{
if (resource == null)
{
throw new ArgumentNullException("resource");
}
resource.Settings.SettingsList.ForEach(setting =>
{
var settingInfoData = settingsData[setting.GetType()];
if (settingInfoData == null) return;
if (!settingInfoData.PreDeclaration) return;
if (settingInfoData.ResourceType != SettingsCollectionResourceType.Input) return;
_builderBase.Append(" ");
_builderBase.Append(setting.GetAndValidateString());
});
}
public abstract bool Run(CommandInput ci, IList<CommandError> errors);
private void WriteResource(CommandInput resource)
{
if (resource == null)
{
throw new ArgumentNullException("resource");
}
var settingsData = Validate.GetSettingCollectionData(resource.Settings);
WriteResourcePreSettings(resource, settingsData);
var inputResource = new Input(resource.Resource);
_builderBase.Append(" ");
_builderBase.Append(inputResource);
WriteResourcePostSettings(resource, settingsData);
}
public abstract bool CanRun(CommandInput ci);
public static MetadataInfoTreeSource Create(CommandInput commandResource)
{
var treeSourceFromInput = new MetadataInfoTreeSource(commandResource.Resource, commandResource.Settings);
return treeSourceFromInput;
}
public void ProcessInput(CommandInput input, bool findSimilar)
{
if (this.Commands.Any(x => string.IsNullOrWhiteSpace(x.Keyword)))
{
throw new ApplicationException("Some commands have no keyword set.");
}
var commands = this.Commands.Where(x => x.Keyword == input.Keyword).ToList();
if (commands.Any())
{
if (commands.Count == 1)
{
var exec = commands.Single();
this.FoundCommand(this.Output, input, exec);
}
else
{
throw new ApplicationException($"More commands with same name: {input.Keyword}");
}
}
else
{
this.UnknownCommand(this.Output, input);
}
}
