public HelpCommand(IHelpCommandDisplayer display, ICommandContainer commands) { Name = "?"; this.commands = commands; this.display = display; Description = "Causes help."; }
public async Task Command_should_be_produced_by_valid_ingestion_service() { var messagesCollectorMock = new Mock <IAsyncCollector <EventData> >(); var loggerMock = new Mock <ILogger>(); messagesCollectorMock .Setup(x => x.AddAsync(It.IsAny <EventData>(), default)) .Returns( Task.CompletedTask ); var command = new DefaultCommand { Header = new MessageHeader(Guid.NewGuid().ToString(), nameof(DefaultCommand), nameof(Sources.Orchestrator)), }; Producer producer = new Producer(messagesCollectorMock.Object, loggerMock.Object); ProducerResult result = await producer.ProduceCommandWithRetryAsync(command); ICommandContainer commandContainer = DeserializeEventData(result.Message); MessageHeader header = GetCommandHeader(commandContainer); Assert.True(result.Valid); Assert.NotEqual(header.MessageId, command.Header.MessageId); Assert.NotEqual(header.CreationDate, command.Header.CreationDate); Assert.Equal(header.TransactionId, command.Header.TransactionId); Assert.Equal(header.MessageType, command.Header.MessageType); Assert.Equal(header.Source, command.Header.Source); }
public void Register(ICommandContainer container) { container.Register(Command.For("sampleA").WithDescription("Sample command registration with delegate.").WithHelp("Help for sample command registration delegate").AddAction(() => { Console.WriteLine("Sample command execution"); })); }
public CommandContainerManager(ILifetimeScope scope, ICommandContainer container, ILogger <CommandContainerManager> logger) { CommandContainer = container; CommandContainerType = container.GetType(); Logger = logger; CurrentScope = scope; }
private async Task DispatchCommandAsync(ICommandContainer commandContainer, string commandType) { if (processors.ContainsKey(commandType)) { await processors[commandType].ProcessAsync(commandContainer); } }
/// <summary> /// Launch the workitem /// </summary> public async Task <IObservable <WorkitemEventArgs> > Run() { // WorkitemID must be set before any operation takes place WorkItemID = Guid.NewGuid().ToString(); Disposables = new List <IDisposable>(); var channel = new WorkitemCommunicationChannel(); communicationChannel = channel; BeforeWorkitemRun(); IsOpen = true; await Create().ConfigureAwait(false); viewContainer = CreateViewContainer(); Disposable(viewContainer); RegisterViews(viewContainer); ICommandContainer container = CreateCommandContainer(); Disposable(container); RegisterCommands(container); AfterWorkitemRun(); return(communicationChannel); }
public PortfolioModel(IQueryContainer queries, ICommandContainer commands, UserManager userManager) { _queries = queries; _commands = commands; _userManager = userManager; }
public void Register(ICommandContainer container) { container.Register(Command.For("sampleA").WithDescription("Sample command registration with delegate.").WithHelp("Help for sample command registration delegate").AddAction(() => { Console.WriteLine("Sample command execution"); })); container.Register(Command.For("sampleB").WithDescription("Sample command registration with class.").WithHelp("Help for sample command registration class").ImplementedBy(new SampleCommandDefinition())); }
public static CommandInfo FindCommand(this ICommandContainer root, string name) { var result = root.Commands.FirstOrDefault(c => c.Name.Equals(name, StringComparison.OrdinalIgnoreCase)); if (result == null) { result = root.Commands.FirstOrDefault(c => c.Aliases.Contains(name, StringComparer.OrdinalIgnoreCase)); } return(result); }
private CommandTree ParseCommand( CommandTreeParserContext context, ICommandContainer current, CommandTree parent, TokenStream stream) { context.ResetArgumentPosition(); // Find the command. var commandToken = stream.Consume(Token.Type.String); var command = current.FindCommand(commandToken.Value); if (command == null) { throw new CommandAppException($"Unknown command '{commandToken.Value}'."); } var node = new CommandTree(parent, command); while (stream.Peek() != null) { var token = stream.Peek(); switch (token.TokenType) { case Token.Type.LongOption: // Long option ParseOption(context, stream, node, true); break; case Token.Type.ShortOption: // Short option ParseOption(context, stream, node, false); break; case Token.Type.String: // Command ParseString(context, stream, node); break; default: throw new InvalidOperationException("Unknown token type."); } } // Add unmapped parameters. foreach (var parameter in node.Command.Parameters) { if (node.Mapped.All(m => m.Item1 != parameter)) { node.Unmapped.Add(parameter); } } return(node); }
public async Task ProcessCommandAsync(ICommandContainer commandContainer) { if (commandContainer == null) { throw new ArgumentException(); } MessageHeader header = GetCommandHeader(commandContainer); string commandType = GetCommandType(header); await DispatchCommandAsync(commandContainer, commandType); }
public void RaiseCommand() { if (!string.IsNullOrEmpty(Command)) { ICommandContainer container = Container as ICommandContainer; if (container != null) { CommandEventArgs e = new CommandEventArgs(Command, this, null); container.RaiseCommand(e); } } }
public void Register(ICommandContainer container) { container.Register(Command.For("help").WithDescription("Provides Help information for commands.").AddAction((args) => { if (args == null || args.Length == 0) { Console.WriteLine("For more information on a specific command, type HELP command-name"); var maxCommandLength = container.Commands.Max(x => x.Key.Length); var marginLeft = maxCommandLength + 5; var rigthPartPos = marginLeft % Console.BufferWidth; var chunkSize = Console.BufferWidth - rigthPartPos; var displayFormat = "{0,-" + marginLeft + "}"; foreach (var item in container.Commands.OrderBy(x => x.Key)) { var leftPart = string.Format(displayFormat, item.Key.ToUpper()); Console.Write(leftPart); if (item.Description.Length > chunkSize) { var chunks = new List<string>(); chunks.AddRange(Enumerable.Range(0, item.Description.Length / chunkSize).Select(i => item.Description.Substring(i * chunkSize, chunkSize))); chunks.Add(item.Description.Length % chunkSize > 0 ? item.Description.Substring((item.Description.Length / chunkSize) * chunkSize, item.Description.Length - ((item.Description.Length / chunkSize) * chunkSize)) : string.Empty); foreach (var chunk in chunks) { var rigthPart = string.Format("{0,-" + (rigthPartPos - Console.CursorLeft) + "}{1}", string.Empty, chunk); if (chunk.Length == chunkSize) Console.Write(rigthPart); else Console.WriteLine(rigthPart); } } else { Console.WriteLine(item.Description); } } } else { var command = container.Commands.FirstOrDefault(x => string.Compare(x.Key, args[0], StringComparison.InvariantCultureIgnoreCase) == 0); if (command == null) Console.WriteLine("Command '{0}' not found.", args[0]); else if (!string.IsNullOrEmpty(command.Help)) Console.WriteLine(command.Help); } })); container.Register(Command.For("exit").WithDescription("Exits power shell.").WithHelp("Enter EXIT to close the program").AddAction(() => { Environment.Exit(0); })); }
public SignalCommandBinding( ICommandContainer container, object key, object name, Resolver resolver) : base( container, key, name, resolver) { }
public CommandBinding(ICommandContainer container, object key, object name, Resolver resolver) : base(key, name, resolver) { Requires.NotNull(container, nameof(container)); this.container = container; }
/// <summary> /// Executes a CommandChain from the beginning. /// </summary> /// <param name="commandChain"></param> /// <param name="onlyIFinallyCommands">indicates errors, if true only finally commands are executed. If an finally command throws an exceptions, remaining finally commands are still executed.</param> protected virtual void Execute(IList <ICommandContainer> commandChain, bool onlyIFinallyCommands, CommandRegistryFinishedCallback registryFinishedCallback = null) { if (commandChain.Count < 1) { String error = "It is not allowed to call execute with a command-chain of size zero."; Log.Error(error); throw new ArgumentException(error); } ICommandContainer commandContainer = commandChain[0]; if (onlyIFinallyCommands) { if (!(commandContainer.Command is IFinallyCommand)) { ExecuteRecursion(commandChain, onlyIFinallyCommands, registryFinishedCallback); return; } } ICommand command = commandContainer.Command; Object commandParameter = commandContainer.CommandParameter; if ((command is IAsyncCommand) || ((command is CommandRegistry) && ((CommandRegistry)command).IsAsync)) { // The command works asynchronously, thus we must wait until all operations initiated by the command // are finished, before we can go on with the next command. // Therefore, we acquire a unique Id to identify the async command and we associate the index of the // following command with this index. IAsyncCommand asyncCommand = (IAsyncCommand)command; long processSequenceId = AcquireCommand(); // The async command is called with the NextCommand delegate: asyncCommand.Execute(commandParameter, delegate(bool success) { //commandChain, processSequenceId and onlyIFinallyCommands are stored (closure). AsyncExecuteRecursion(commandChain, processSequenceId, success, onlyIFinallyCommands, registryFinishedCallback); }); return; } // The command works synchronously, thus we can directly proceed with the next command: try { command.Execute(commandParameter); } catch (Exception ex) { Log.Warn("Execution of the command '" + command.GetType().Name + "' with parameter '" + commandParameter.GetType().Name + "' lead to the following exception: " + ex); onlyIFinallyCommands = true; } ExecuteRecursion(commandChain, onlyIFinallyCommands, registryFinishedCallback); }
private static XmlDocument Serialize(ICommandContainer model) { var document = new XmlDocument(); var root = document.CreateElement("model"); foreach (var command in model.Commands) { root.AppendChild(document.CreateComment(command.Name.ToUpperInvariant())); root.AppendChild(CreateCommandNode(document, command)); } document.AppendChild(root); return(document); }
public static CommandInfo?FindCommand(this ICommandContainer root, string name, CaseSensitivity sensitivity) { var result = root.Commands.FirstOrDefault( c => c.Name.Equals(name, sensitivity.GetStringComparison(CommandPart.CommandName))); if (result == null) { result = root.Commands.FirstOrDefault( c => c.Aliases.Contains(name, sensitivity.GetStringComparer(CommandPart.CommandName))); } return(result); }
/// <summary> /// Add all commands in a command container /// </summary> /// <param name="container"></param> internal void AddCommands(ICommandContainer container) { MethodInfo[] methods = container.GetType().GetMethods(); for (int i = 0; i < methods.Length; i++) { MethodInfo method = methods[i]; if (method.GetCustomAttribute <Command>() != null) { AddCommand(container, method); } } }
public bool TryReadCommand(out ICommandContainer commandTransport) { if (_commandTransports.Any()) { // TODO: fix thread safety return(_commandTransports.TryRemove(_commandTransports.Keys.First(), out commandTransport)); } else { commandTransport = default; return(false); } }
/// <summary> /// Adds or set the command. /// </summary> /// <param name="key">The command key.</param> /// <param name="command">The command.</param> public void AddOrSetCommand(string key, ICommandContainer command) { if (string.IsNullOrEmpty(key) == false) { if (this.commandContainers.Any(k => k.Key == key)) { this.commandContainers[key] = command; } else { this.commandContainers.AddOrUpdate(key, command, (exkey, excmd) => command); } } }
public virtual void UnregisterCommand(ICommand command, String parameterKey, int priority) { CommandKey commandKey = new CommandKey(command, parameterKey, priority); ICommandContainer commandContainer = keyToCommandContainer.GetExtension(commandKey); if (!AlwaysExecutable) { commandContainer.CanExecuteChanged -= OnCanExecuteChanged; } if ((command is IAsyncCommand) || ((command is CommandRegistry) && ((CommandRegistry)command).IsAsync)) { --nAsyncCommandsRegistered; } keyToCommandContainer.Unregister(commandContainer, commandKey); }
public virtual void RaiseCommand(CommandEventArgs e) { if (Command != null) { Command(this, e); } if (!e.Handled) { ICommandContainer container = this.Container as ICommandContainer; if (container != null) { container.RaiseCommand(e); } } }
public async Task ProcessAsync(ICommandContainer commandContainer) { var validateCommand = commandContainer.ParseCommand <IssueReceiptCommand>(); var header = validateCommand.Header; var content = validateCommand.Content; try { await CreateReceiptAsync(header, content); } catch (Exception exception) { await ProcessFailure(header, exception); } }
public async Task ProcessAsync(ICommandContainer commandContainer) { var validateCommand = commandContainer.ParseCommand <CancelTransferCommand>(); var header = validateCommand.Header; var content = validateCommand.Content; try { await CancelTransferAsync(header, content); } catch (Exception exception) { await ProcessCancellationFailureAsync(header, exception); } }
private CommandTree ParseCommand( CommandTreeParserContext context, ICommandContainer current, CommandTree parent, CommandTreeTokenStream stream) { // Find the command. var commandToken = stream.Consume(CommandTreeToken.Kind.String); var command = current.FindCommand(commandToken.Value); if (command == null) { throw ParseException.UnknownCommand(_configuration, parent, context.Arguments, commandToken); } return(ParseCommandParameters(context, command, parent, stream)); }
protected BotProgram() { AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException; _logger.Info("Starting Bot v{0} on {1}({2})", Assembly.GetEntryAssembly().GetName().Version, Environment.MachineName, Environment.OSVersion.VersionString); //Configure Dependency Injection IServiceCollection serviceCollection = new ServiceCollection(); ConfigureServices(serviceCollection); serviceCollection.AddSingleton(_discordClient); serviceCollection.TryAddSingleton(new BotConfiguration()); //Add default bot configuration if not already added IServiceProvider serviceProvider = serviceCollection.BuildServiceProvider(); //Configure Command Container BotConfiguration config = serviceProvider.GetService <BotConfiguration>(); ICommandContainer container = BuildCommandContainer(); container.AddCommandHandler <HelpCommand>(); container.AddCommandHandler <PrivateCommand>(); container.AddCommandHandler <PingCommand>(); if (config.EnableDebugCommandsForAdmins) { container.AddCommandHandler <InspectDscCommand>(); container.AddCommandHandler <InfoCommand>(); } else { _logger.Debug("Debug commands are disabled. Not adding them to command container"); } _logger.Info("Added {0} command(s) to container", container.Count()); serviceCollection.AddSingleton(container); serviceProvider = serviceCollection.BuildServiceProvider(); //Build ServiceProvider agein with ICommandContainer //Configure global filter IEnumerable <CommandFilter> globalFilter = ConfigureGlobalFilter().ToList(); foreach (CommandFilter commandFilter in globalFilter) { _logger.Debug("Loaded global filter \"{0}\"", commandFilter.GetType().FullName); } _logger.Info("Added {0} global filter(s)", globalFilter.Count()); //Configure Event Handler _newMessageHandler = new NewMessageHandler(serviceProvider, container, globalFilter); }
public CommandHelp(ILifetimeScope scope, ICommandContainer container, ICommandContainerManager manager) { CommandContainerType = container.GetType(); var containerLoggerType = typeof(ILogger <>).MakeGenericType(CommandContainerType); Logger = scope.Resolve(containerLoggerType) as ILogger; CommandInformation = new Dictionary <string, CommandInfo>(); foreach (var(methodInfo, handlerAttr, _) in manager.ResolveHandlers()) { var description = methodInfo.GetCustomAttribute <CommandDescriptionAttribute>()?.Description ?? "-"; CommandInformation.Add(handlerAttr.Command, new CommandInfo() { Name = handlerAttr.Command, Description = description }); } }
/// <summary> /// Initializes a new instance of the <see cref="UserInterfaceService"/> class. /// </summary> /// <param name="container">The container that stores all the references for the application.</param> /// <param name="onStartService"> /// The method that stores the IOC container that contains the references for the entire application. /// </param> /// <param name="diagnostics">The object that provides the diagnostics methods for the application.</param> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="container"/> is <see langword="null"/>. /// </exception> /// <exception cref="ArgumentNullException"> /// Thrown when <paramref name="onStartService"/> is <see langword="null"/>. /// </exception> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="diagnostics"/> is <see langword="null" />. /// </exception> public UserInterfaceService(IContainer container, Action <IContainer> onStartService, SystemDiagnostics diagnostics) : base(diagnostics) { { Enforce.Argument(() => container); Enforce.Argument(() => onStartService); } m_Container = container; m_NotificationNames = container.Resolve <INotificationNameConstants>(); m_Diagnostics = container.Resolve <SystemDiagnostics>(); m_OnStartService = onStartService; m_Commands = container.Resolve <ICommandContainer>(); { m_Commands.Add( ShutdownApplicationCommand.CommandId, () => new ShutdownApplicationCommand(() => m_Core.Shutdown())); m_Commands.Add( CreateProjectCommand.CommandId, () => new CreateProjectCommand( () => { m_Projects.CreateNewProject(); return(m_Projects.Current); })); m_Commands.Add( LoadProjectCommand.CommandId, () => new LoadProjectCommand( persistenceInformation => { m_Projects.LoadProject(persistenceInformation); return(m_Projects.Current); })); m_Commands.Add( UnloadProjectCommand.CommandId, () => new UnloadProjectCommand(() => m_Projects.UnloadProject())); } }
private static Task RegisterCommands(ICommandContainer container) { try { Task.WaitAll(new[] { container.AddModuleAsync <TeleportModule>(), container.AddModuleAsync <ButcherModule>(), container.AddModuleAsync <ItemModule>(), container.AddModuleAsync <CharacterModule>(), container.AddModuleAsync <HelpModule>() }); } catch (Exception e) { Log.Debug(e.StackTrace); } return(Task.CompletedTask); }
protected virtual void OnCanExecuteChanged(Object sender, EventArgs e) { ICommandContainer sendingContainer = (ICommandContainer)sender; if (!GuiThreadHelper.IsInGuiThread()) { String error = "The command " + sendingContainer.Command.GetType().FullName + " has fired CanExecuteChanged from a non-UI thread. This is illegal!"; Log.Error(error); throw new Exception(error); } // CanExecuteChanged may be expensive methods for some registered commands // => avoid unnecessary evaluations if (canExecuteChangedState == null) { // State was never set => set it for the first time DetermineCanExecuteChangedState(); RaiseCanExecuteChanged(); return; } bool senderState = sendingContainer.Command.CanExecute(sendingContainer.CommandParameter); if (senderState == canExecuteChangedState) { // Senders state equals total state => no need to evaluate other states and no need to fire event return; } if (canExecuteChangedState == true) { // total state is true and senders state is false => set total to false and fire event canExecuteChangedState = false; RaiseCanExecuteChanged(); return; } // total state is false, but senders state has turned to true => check whether there is any // other command with state false => if not, change total state to true and fire event DetermineCanExecuteChangedState(); if (canExecuteChangedState == true) { RaiseCanExecuteChanged(); } }
/// <summary> /// Initializes a new instance of the <see cref="UserInterfaceService"/> class. /// </summary> /// <param name="container">The container that stores all the references for the application.</param> /// <param name="onStartService"> /// The method that stores the IOC container that contains the references for the entire application. /// </param> /// <param name="diagnostics">The object that provides the diagnostics methods for the application.</param> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="container"/> is <see langword="null"/>. /// </exception> /// <exception cref="ArgumentNullException"> /// Thrown when <paramref name="onStartService"/> is <see langword="null"/>. /// </exception> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="diagnostics"/> is <see langword="null" />. /// </exception> public UserInterfaceService(IContainer container, Action<IContainer> onStartService, SystemDiagnostics diagnostics) : base(diagnostics) { { Enforce.Argument(() => container); Enforce.Argument(() => onStartService); } m_Container = container; m_NotificationNames = container.Resolve<INotificationNameConstants>(); m_Diagnostics = container.Resolve<SystemDiagnostics>(); m_OnStartService = onStartService; m_Commands = container.Resolve<ICommandContainer>(); { m_Commands.Add( ShutdownApplicationCommand.CommandId, () => new ShutdownApplicationCommand(() => m_Core.Shutdown())); m_Commands.Add( CreateProjectCommand.CommandId, () => new CreateProjectCommand( () => { m_Projects.CreateNewProject(); return m_Projects.Current; })); m_Commands.Add( LoadProjectCommand.CommandId, () => new LoadProjectCommand( persistenceInformation => { m_Projects.LoadProject(persistenceInformation); return m_Projects.Current; })); m_Commands.Add( UnloadProjectCommand.CommandId, () => new UnloadProjectCommand(() => m_Projects.UnloadProject())); } }