public Maybe <TError> Process(IHandleCommand <TCommand, TError> commandHandler) => _inner.Process(commandHandler).Match(SendErrorResult, SendSuccessResult);
public void RegisterHandler <T>(IHandleCommand <T> handler)
{
_handlers[typeof(T)] = handler;
}
public static ArchiveFeatureController GivenController(
this ArchiveFeatureControllerTests tests,
IHandleCommand <ArchiveFeatureCommand> handler)
{
return(new ArchiveFeatureController(handler));
}
public EnsurePoolSizeHandler(IPoolsRepository repository, TelemetryClient telemetryClient, IHandleCommand <PushVacantInstance> addVacantInstance)
{
this.repository = repository;
this.telemetryClient = telemetryClient;
this.addVacantInstance = addVacantInstance;
}
public UnAssignStrategyController(IHandleCommand <UnAssignStrategyCommand> handleCommand)
{
this._handleCommand = handleCommand;
}
public static AssignIsAfterStrategyToFeatureController GivenController(
this AssignIsAfterStrategyToFeatureControllerTests tests,
IHandleCommand <AssignIsAfterStrategyToFeatureCommand> handler)
{
return(new AssignIsAfterStrategyToFeatureController(handler));
}
public CreateFeatureController(IHandleCommand <CreateFeatureCommand> handleCommand)
{
this._handleCommand = handleCommand;
}
public CommandHandler(IPublisher bus, IHandleCommand <T> handler)
{
_bus = bus;
_handler = handler;
CancelHandler = new AdHocHandler <CancelCommand>(RequestCancel);
}
protected void When(T command, IHandleCommand <T> commandHandler)
{
_command = command;
_commandHandler = commandHandler;
}
public PublishFeatureController(IHandleCommand <PublishFeatureCommand> handleCommand)
{
this._handleCommand = handleCommand;
}
public static Func <Task> WhenCreatingAFeature(
this IHandleCommand <CreateFeatureCommand> handler,
CreateFeatureCommand command)
{
return(() => handler.Handle(command));
}
public static NoResult NoResultInstance <T, R>(this IHandleCommand <T, R> handler) where T : class where R : class
{
return(NoResult.Instance);
}
public static CreateFeatureController GivenController(
this CreateFeatureControllerTests tests,
IHandleCommand <CreateFeatureCommand> handler)
{
return(new CreateFeatureController(handler));
}
public void Register <T>(IHandleCommand <T> handler) where T : BaseCommand
{
_registrations.Add(typeof(T), cmd => handler.Handle((T)cmd));
}
public Dispatching_commands()
{
_resolver = Substitute.For <IResolver>();
_executor = Substitute.For <IExecuteCommands>();
_handler = Substitute.For <IHandleCommand <TestCommand> >();
}
public AssignIsGreaterThanStrategyToFeatureController(IHandleCommand <AssignIsGreaterThanStrategyToFeatureCommand> handleCommand)
{
this._handleCommand = handleCommand;
}
/// <summary>
/// Returns a value indicating whether the command handler is a saga.
/// </summary>
/// <typeparam name="TCommand">The typeof command.</typeparam>
/// <param name="commandHandler">The <see cref="IHandleCommand{T}">command handler</see> to evaluate.</param>
/// <returns>True if the <paramref name="commandHandler">command handler</paramref> is a saga; otherwise, false.</returns>
public static bool IsSaga <TCommand>(this IHandleCommand <TCommand> commandHandler) where TCommand : ICommand
{
Arg.NotNull(commandHandler, nameof(commandHandler));
return(commandHandler.GetType().IsSaga());
}
public CommandController(IHandleCommand <TCommand> handler)
{
_handler = handler ?? throw new ArgumentNullException(nameof(handler));
}
public CommandConsumer(IHandleCommand <TCommand> commandHandler)
{
this.commandHandler = commandHandler;
}
public static Func <Task> WhenArchiveingAFeature(
this IHandleCommand <ArchiveFeatureCommand> handler,
ArchiveFeatureCommand command)
{
return(() => handler.Handle(command));
}
public IDisposable Subscribe <T>(IHandleCommand <T> handler) where T : Command
{
return(_target?.Subscribe(handler));
}
public StartPoolHandler(IPoolsRepository repository, IHandleCommand <EnsurePoolSize> ensurePoolSize)
{
this.repository = repository;
this.ensurePoolSize = ensurePoolSize;
}
public void Unsubscribe <T>(IHandleCommand <T> handler) where T : Command
{
_target?.Unsubscribe(handler);
}
public MediatRHandlerAdopte(IHandleCommand <Tcommand> OurHandler)
{
this.OurHandler = OurHandler;
}
public RetryingCommandHandler(IHandleCommand <T> next) => _next = next;
public static Func <Task> WhenPublishingAFeature(
this IHandleCommand <PublishFeatureCommand> handler,
PublishFeatureCommand command)
{
return(() => handler.Handle(command));
}
public void Dispatch <TCommand>(TCommand command) where TCommand : class, ICommand
{
IHandleCommand <TCommand> commandHandler = _provider.GetService <IHandleCommand <TCommand> >();
commandHandler.Handle(command);
}
public void Add <T>(IHandleCommand <T> fakeHandler)
{
_handlers.Add(typeof(T).FullName, fakeHandler);
}
public static Func <Task> WhenPublishingAFeature(
this IHandleCommand <AssignIsGreaterThanStrategyToFeatureCommand> handler,
AssignIsGreaterThanStrategyToFeatureCommand command)
{
return(() => handler.Handle(command));
}
public CommandValidator(ILogger log, IEnumerable <IValidator <TCommand> > validators, IHandleCommand <TCommand> commandHandler)
{
_log = log;
_validators = validators;
_commandHandler = commandHandler;
}
public void Subscribe(IHandleCommand handler)
{
handlers.Add(handler);
}
