/// <param name="getProductsQueryHandler"></param>
/// <param name="getProductDetailsQueryHandler"></param>
/// <param name="addProductCommandHandler"></param>
/// <param name="editProductCommandHandler"></param>
public ProductsController(IQueryHandler <GetProductsQuery, GetProductsResponse> getProductsQueryHandler, IAsyncQueryHandler <GetProductDetailsQuery, GetProductDetailsResponse> getProductDetailsQueryHandler, IAsyncCommandHandler <AddProductCommand, AddProductResponse> addProductCommandHandler, IAsyncCommandHandler <EditProductCommand, EditProductResponse> editProductCommandHandler)
{
_getProductsQueryHandler = getProductsQueryHandler;
_getProductDetailsQueryHandler = getProductDetailsQueryHandler;
_addProductCommandHandler = addProductCommandHandler;
_editProductCommandHandler = editProductCommandHandler;
}
public FileUploadsController(IAsyncCommandHandler <UploadTeabagImageCommand> uploadFileCommand,
IUrlHelper urlHelper,
ITranslator <ICommandResult, IActionResult> translator)
{
UploadFileCommand = uploadFileCommand ?? throw new ArgumentNullException(nameof(uploadFileCommand));
Translator = translator ?? throw new ArgumentNullException(nameof(translator));
}
public GenericPermissionCheckAsyncCommandHandlerDecorator(IAsyncCommandHandler <TCommand> wrappedHandler, IIdentity currentUser, IAsyncPermissionCheck <TCommand> check, ILogger <GenericPermissionCheckAsyncCommandHandlerDecorator <TCommand> > logger)
{
this.wrappedHandler = wrappedHandler ?? throw new ArgumentNullException(nameof(wrappedHandler));
this.currentUser = currentUser ?? throw new ArgumentNullException(nameof(currentUser));
this.check = check ?? throw new ArgumentNullException(nameof(check));
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public AsyncCommandHandlerWithLogging(IAsyncCommandHandler <TCommand> commandHandler, ILogger logger)
{
Condition.Requires(commandHandler, nameof(commandHandler)).IsNotNull();
Condition.Requires(logger, nameof(logger)).IsNotNull();
this.commandHandler = commandHandler;
this.logger = logger;
}
public SynchronisationController(
IAsyncQueryHandler <CommitQuery, CommitSynchronisation> queryHandler,
IAsyncCommandHandler <CommitSynchronisableCommits> commandHandler)
{
this.queryHandler = queryHandler;
this.commandHandler = commandHandler;
}
public AsyncPollyCommandHandler(IAsyncCommandHandler <TCommand> handler, IAsyncPolicy policy)
{
Condition.Requires(handler, nameof(handler)).IsNotNull();
Condition.Requires(policy, nameof(policy)).IsNotNull();
this.handler = handler;
this.policy = policy;
}
public OvladaciPanelPresenter(IOvladaciPanelView view,
IAsyncCommandHandler <ZobrazDataCommand> zobrazHandler,
IErrorDisplayService errorDisplayService) : base(view)
{
this.zobrazHandler = zobrazHandler;
this.errorDisplayService = errorDisplayService;
View.Zobraz += View_Zobraz;
}
/// <param name="addUserMealCommandHandler"></param>
/// <param name="getUserMealsByDate"></param>
/// <param name="deleteUserMeals"></param>
public UserMealsController(IAsyncCommandHandler <AddUserMealCommand, AddUserMealResponse> addUserMealCommandHandler,
IAsyncQueryHandler <GetUserMealsByDateInternalQuery, GetUserMealsByDateResponse> getUserMealsByDate,
IAsyncCommandHandler <DeleteUserMealsCommand, DeleteUserMealsReponse> deleteUserMeals)
{
_addUserMealCommandHandler = addUserMealCommandHandler;
_getUserMealsByDate = getUserMealsByDate;
_deleteUserMeals = deleteUserMeals;
}
protected AzureDataContextAsyncCommandHandler(
IAsyncCommandHandler <T> inner,
DataContextLookup lookup,
string localDbName)
{
this.inner = inner;
this.lookup = lookup;
this.localDbName = localDbName;
}
public TransactedAsyncCommandHandler(
IAsyncCommandHandler <TCommand> decorated,
ISuspendExecutionStrategy suspendExecutionStrategy,
ILoggingService loggingService)
{
Decorated = decorated;
this.suspendExecutionStrategy = suspendExecutionStrategy;
this.loggingService = loggingService;
}
public void Setup()
{
command = new TestCommand();
commandHandler = Substitute.For<IAsyncCommandHandler<TestCommand>>();
commandHandlerResolver = Substitute.For<ICommandHandlerResolver>();
commandHandlerResolver.ResolveCommandHandler<IAsyncCommandHandler<TestCommand>>().Returns(commandHandler);
sut = new AsyncCommandBus(commandHandlerResolver);
}
public LoggedAsyncCommandHandlerDecorator(
IAsyncCommandHandler <TCommand> decorated,
ILoggingService logger,
IContractResolver contractResolver)
{
Decorated = decorated;
this.contractResolver = contractResolver;
this.logger = logger;
logger.SetLoggerName("Command Handler");
}
public StudentsCommandController(
IAsyncCommandHandler <UpdateStudentCommand> updateStudent,
IAsyncCommandHandler <CreateStudentCommand> createStudent,
IAsyncCommandHandler <DeleteStudentCommand> deleteStudent)
{
_updateStudent = updateStudent;
_createStudent = createStudent;
_deleteStudent = deleteStudent;
}
public EntityFrameworkDatabaseSeedDataAsyncInitializer(
IAsyncQueryHandler <GetSchoolInitializationStatusQuery, Result <bool, Exception> > getSchoolInitializationStatusQueryHandler,
IAsyncCommandHandler <SaveStudentDataCommand, Exception> saveStudentDataCommandHandler,
IAsyncCommandHandler <SaveCourseDataCommand, Exception> saveCourseDataCommandHandler,
IAsyncCommandHandler <SaveEnrollmentDataCommand, Exception> saveEnrollmentDataCommandHandler)
{
_getSchoolInitializationStatusQueryHandler = getSchoolInitializationStatusQueryHandler ?? throw new ArgumentNullException(nameof(getSchoolInitializationStatusQueryHandler));
_saveStudentDataCommandHandler = saveStudentDataCommandHandler ?? throw new ArgumentNullException(nameof(saveStudentDataCommandHandler));
_saveCourseDataCommandHandler = saveCourseDataCommandHandler ?? throw new ArgumentNullException(nameof(saveCourseDataCommandHandler));
_saveEnrollmentDataCommandHandler = saveEnrollmentDataCommandHandler ?? throw new ArgumentNullException(nameof(saveEnrollmentDataCommandHandler));
}
public virtual void Validate <TCommand>(TCommand command, IAsyncCommandHandler <TCommand> commandHandler, IExecutionContext executionContext) where TCommand : ICommand
{
ValidateCommmandImplementation <TCommand>(commandHandler);
if (commandHandler is IPermissionRestrictedCommandHandler <TCommand> )
{
var permissions = ((IPermissionRestrictedCommandHandler <TCommand>)commandHandler).GetPermissions(command);
_permissionValidationService.EnforcePermission(permissions, executionContext.UserContext);
}
CheckAdditionalPermissionHandlers(commandHandler, executionContext, _permissionValidationService);
}
/// <param name="addMealCommandHandler"></param>
/// <param name="getMealsQueryHandler"></param>
/// <param name="mealDetailsQueryHandler"></param>
/// <param name="editMealCommandHandler"></param>
/// <param name="deleteMealCommandHandler"></param>
public MealsController(IAsyncCommandHandler <AddMealCommand, AddMealResponse> addMealCommandHandler,
IAsyncQueryHandler <GetMealsQuery, GetMealsResponse> getMealsQueryHandler,
IAsyncQueryHandler <GetMealDetailsQuery, GetMealDetailsResponse> mealDetailsQueryHandler,
IAsyncCommandHandler <EditMealCommand, EditMealResponse> editMealCommandHandler,
IAsyncCommandHandler <DeleteMealCommand, DeleteMealResponse> deleteMealCommandHandler)
{
_addMealCommandHandler = addMealCommandHandler;
_getMealsQueryHandler = getMealsQueryHandler;
_mealDetailsQueryHandler = mealDetailsQueryHandler;
_editMealCommandHandler = editMealCommandHandler;
_deleteMealCommandHandler = deleteMealCommandHandler;
}
public IAsyncCommandHandler Build(IAsyncCommandHandler handler, bool orderByPriority = true)
{
var nextHandler = handler;
foreach (var policy in _policies.OrderBy(x => orderByPriority ? x.Priority : -1))
{
policy.SetNextNode(nextHandler);
nextHandler = policy;
}
return(nextHandler);
}
public async Task <TCommandResult> Handle <TCommand, TCommandResult>(TCommand command)
where TCommand : ICommand
where TCommandResult : ICommandResult, new()
{
bool async = false;
IAsyncCommandHandler <TCommand, TCommandResult> asyncHandler = null;
ICommandHandler <TCommand, TCommandResult> handler = _serviceProvider.GetService(typeof(ICommandHandler <TCommand, TCommandResult>)) as ICommandHandler <TCommand, TCommandResult>;
if (handler == null)
{
async = true;
asyncHandler = _serviceProvider.GetService(typeof(IAsyncCommandHandler <TCommand, TCommandResult>)) as IAsyncCommandHandler <TCommand, TCommandResult>;
}
if (handler == null && asyncHandler == null)
{
throw new ArgumentNullException(nameof(handler));
}
TCommandResult result = new TCommandResult();
try
{
_logService.Log <ICommandHandler <TCommand, TCommandResult> >(nameof(EOperations.Input), nameof(handler.Handle), new { Input = command }, LogLevel.Debug);
result = async ? await asyncHandler.Handle(command) : handler.Handle(command);
if (result == null)
{
result = new TCommandResult();
IReadOnlyDictionary <string, IReadOnlyCollection <INotificationMessage> > notifications = async ? asyncHandler.Notifications : handler.Notifications;
if (notifications.Count > 0)
{
result.Populate(InvalidHandlerDefaultCode, notifications);
}
}
}
catch (Exception exception)
{
_logService.Log <ICommandHandler <TCommand, TCommandResult> >(exception, new { Input = command }, LogLevel.Error);
}
finally
{
_logService.Log <ICommandHandler <TCommand, TCommandResult> >(nameof(EOperations.Output), nameof(handler.Handle), new { Output = result }, LogLevel.Debug);
}
return(result);
}
/// <param name="registerUserCommandHandler"></param>
/// <param name="loginUserCommandHandler"></param>
/// <param name="getUsersQueryHandler"></param>
/// <param name="userDetailsQueryHandler"></param>
/// <param name="disableUserCommandHandler"></param>
/// <param name="enableUserCommandHandler"></param>
public UsersController(IAsyncCommandHandler <RegisterUserCommand, RegisterUserResponse> registerUserCommandHandler,
IAsyncCommandHandler <LoginUserCommand, LoginUserResponse> loginUserCommandHandler,
IAsyncQueryHandler <GetUsersQuery, GetUsersResponse> getUsersQueryHandler,
IAsyncQueryHandler <GetUserDetailsQuery, UserDetailsResponse> userDetailsQueryHandler,
IAsyncCommandHandler <DisableUserCommand, DisableUserResponse> disableUserCommandHandler,
IAsyncCommandHandler <EnableUserCommand, EnableUserResponse> enableUserCommandHandler)
{
_registerUserCommandHandler = registerUserCommandHandler;
_loginUserCommandHandler = loginUserCommandHandler;
_getUsersQueryHandler = getUsersQueryHandler;
_userDetailsQueryHandler = userDetailsQueryHandler;
_disableUserCommandHandler = disableUserCommandHandler;
_enableUserCommandHandler = enableUserCommandHandler;
}
public BagsController(SearchQueryHandler <Bag, Domain.Tea.Bag> searchBagsCommand,
GetQueryHandler <Bag, Domain.Tea.Bag> getBagType,
IAsyncCommandHandler <UpdateBagCommand> updateCommand,
IAsyncCommandHandler <CreateBagCommand> createCommand,
ITranslator <IQueryResult, IActionResult> queryTranslator,
ITranslator <ICommandResult, IActionResult> commandTranslator)
{
SearchBagsCommand = searchBagsCommand ?? throw new System.ArgumentNullException(nameof(searchBagsCommand));
GetBagType = getBagType ?? throw new System.ArgumentNullException(nameof(getBagType));
UpdateCommand = updateCommand ?? throw new System.ArgumentNullException(nameof(updateCommand));
CreateCommand = createCommand ?? throw new System.ArgumentNullException(nameof(createCommand));
QueryTranslator = queryTranslator ?? throw new System.ArgumentNullException(nameof(queryTranslator));
CommandTranslator = commandTranslator ?? throw new System.ArgumentNullException(nameof(commandTranslator));
}
public CountriesController(SearchQueryHandler <Country, Domain.Tea.Country> searchCountriesCommand,
GetQueryHandler <Country, Domain.Tea.Country> getCountry,
IAsyncCommandHandler <UpdateCommand <Country>, Domain.Tea.Country> updateCommand,
IAsyncCommandHandler <CreateCommand <Country>, Domain.Tea.Country> createCommand,
IAsyncQueryHandler <SearchRefValuesQuery <Domain.Tea.Country> > searchRefValuesQuery,
ITranslator <IQueryResult, IActionResult> queryTranslator,
ITranslator <ICommandResult, IActionResult> commandTranslator)
{
SearchCountriesCommand = searchCountriesCommand ?? throw new System.ArgumentNullException(nameof(searchCountriesCommand));
GetCountry = getCountry ?? throw new System.ArgumentNullException(nameof(getCountry));
UpdateCommand = updateCommand ?? throw new System.ArgumentNullException(nameof(updateCommand));
CreateCommand = createCommand ?? throw new System.ArgumentNullException(nameof(createCommand));
SearchRefValuesQuery = searchRefValuesQuery ?? throw new System.ArgumentNullException(nameof(searchRefValuesQuery));
QueryTranslator = queryTranslator ?? throw new System.ArgumentNullException(nameof(queryTranslator));
CommandTranslator = commandTranslator ?? throw new System.ArgumentNullException(nameof(commandTranslator));
}
/// <summary>
/// Инициализирует экземпляр класса <see cref="BackgroundThreadWorker"/>,
/// используя <paramref name="queue"/> и <paramref name="handler"/>.
/// </summary>
/// <param name="queue">Наблюдаемая очередь.</param>
/// <param name="handler">Обработчик команд.</param>
/// /// <param name="logger"></param>
public BackgroundThreadWorker(IAsyncCommandQueue queue, IAsyncCommandHandler handler, ILogger logger)
{
if (queue == null)
{
throw new ArgumentNullException("queue");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
_queue = queue;
_handler = handler;
Logger = logger;
}
public ToolBarPresenter(IToolBarView view,
IEventAggregator events,
IAsyncCommandHandler <DataToASCIICommand> command) : base(view)
{
this.events = events;
this.command = command;
// EventHandlers
View.ToASCII += ToASCII_Selected;
View.YValueChanged += YValueState_Changed;
events.Subscribe <NewSessionRequest>(e =>
{
View.YValues = e.RowTemplate.NazvySloupcu.Skip(1).ToDictionary(nazev => nazev, i => true);
});
events.Subscribe <ZobrazDataRequest>(e =>
{
aktualniPocatekZobrazenychDat = e.Pocatek;
aktualniKonecZobrazenychDat = e.Konec;
});
}
protected override IGenericValidationAsyncCommandHandlerDecorator <TCommand> GetValidationHandler <TCommand>(IAsyncCommandHandler <TCommand> wrappedHandler)
{
return(this.scope.Resolve <IGenericValidationAsyncCommandHandlerDecorator <TCommand> >(new Parameter[] { new NamedParameter("wrappedHandler", wrappedHandler) }));
}
public AsyncCommandHandlerNotifier(ILogger logger, IAsyncCommandHandler <TCommand> innerHandler)
{
_logger = logger;
_innerHandler = innerHandler;
}
public SaveCommandHandlerDecorator(IAsyncCommandHandler <TCommand> decorated, IUnitOfWork uow)
{
_decorated = decorated;
_uow = uow;
}
protected override string InitializeHandler(string[] command) {
_commandHandler = _dispatcher.GetHandler(_endPoint, command);
return _commandHandler.Command;
}
public RegisterUserController(IAsyncCommandHandler <CreateAccount> createAccountCommandHandler,
AccountContext context)
{
_createAccountCommandHandler = createAccountCommandHandler;
_context = context;
}
public AsyncCommandHandlerStopwatcher(ILogger logger, IAsyncCommandHandler <TCommand> innerHandler)
{
_logger = logger;
_innerHandler = innerHandler;
}
public DatabaseAsyncRetryDecorator(IAsyncCommandHandler <TCommand> commandHandler, ILogger logger,
int retryCount = 3) : base(logger, retryCount)
{
asyncCommandHandler = commandHandler ?? throw new ArgumentNullException(nameof(commandHandler));
}
public void SetNextHandler(IAsyncCommandHandler <TCommand> handler)
{
NextHandler = handler;
}
public void SetNextNode(IAsyncCommandHandler asyncCommandHandler)
{
_asyncCommandHandler = asyncCommandHandler ?? throw new ArgumentNullException(nameof(asyncCommandHandler));
}
public CommandPipelineItem <TCommand> SetNextPipelineItem(CommandPipelineItem <TCommand> handler)
{
NextHandler = handler;
return(handler);
}
