public TResult Process <TCommand, TResult>(ICommand <TCommand, TResult> command) where TCommand : ICommand <TCommand, TResult>
{
var handler = resolver.Resolve(command);
var result = handler.Handle((TCommand)command);
return(result);
}
public async Task <IActionResult> Post([FromBody] Update update)
{
var request = _commandResolver.Resolve(update);
await _mediator.Send(request);
return(Ok());
}
public async Task RunAsync(params string[] args)
{
if (args.Length > 0)
{
var name = args[0];
args = args.Skip(1).ToArray();
try
{
var command = _commandResolver.Resolve(name, args);
await command.ExecuteAsync().ConfigureAwait(false);
if (_options.AutoClose == false)
{
Console.ReadKey();
}
}
catch (Exception e)
{
_logger.LogCritical(e.Message);
}
}
else
{
_logger.LogError("No valid command was specified!");
}
}
private CommandModel FindCommand(string[] commandName)
{
var name = _commandNameParser.Parse(String.Join(" ", commandName));
var context = new Dictionary <string, object>();
ContextHelper.SetCommandName(context, name.Parts as string[] ?? name.Parts.ToArray());
return(_commandResolver.Resolve(context, _appModel.Commands));
}
private async Task OnMessageReceived(object sender, MessageReceived @event)
{
_logger.LogInformation("processing Message '{MessageId}' with type: '{MessageType}' ...", @event.Message.Id, @event.Message.MessageType);
var command = _commandResolver.Resolve(@event.Message);
using var innerScope = _scopeFactory.CreateScope();
var mediatr = innerScope.ServiceProvider.GetRequiredService <MediatR.IMediator>();
await mediatr.Publish(command);
}
public ICraneCommand Create(params string[] args)
{
if (args == null || args.Length == 0)
{
return(new ListCommands());
}
var commandType = _commandResolver.Resolve(_craneCommands, args[0]);
var commandWithArgs = _commandArgParser.Parse(commandType, args);
return(commandWithArgs);
}
public async Task ExecuteCommand(Dictionary <string, object> context)
{
var token = GetCancellationToken(context);
var options = GetOptions(context);
var operands = GetOperands(context);
token.ThrowIfCancellationRequested();
using (var scope = _services.CreateScope())
{
var services = new ArgumentsServiceProvider(scope.ServiceProvider, token);
var command = _commandResolver.Resolve(context, _appModel.Commands);
var arguments = _argumentsParser.Parse(command.Arguments, options, operands, services);
token.ThrowIfCancellationRequested();
await _commandExecutor.ExecuteAsync(
command, arguments, services, token)
.ConfigureAwait(false);
}
}
public T Generate()
{
context = new Evaluator(resolver.Resolve(), context).Evaluate();
return(OnEvaluated());
}
public ICommand <TCommandContext> Create <TCommandContext>()
where TCommandContext : ICommandContext
{
return(commandResolver.Resolve <TCommandContext>());
}
public Task InvokeCommand(string commandName)
{
var command = _commandResolver.Resolve(commandName) ?? _commandResolver.Resolve("undefined") !;
return(_commandInvoker.InvokeCommand(command, _request));
}
