void IHandleCommands <TCommand> .Handle(ICommandHandlingContext <TCommand> handlingContext) { var command = handlingContext.Command; var domainRepository = _domainRepositoryResolver.GetRepository(null); try { var aggregateRoot = domainRepository.GetById <TAggregateRoot>(command.AggregateRootId); ValidateTheCommand(handlingContext, command, aggregateRoot); Handle(command, aggregateRoot); if (aggregateRoot != null) { domainRepository.Save(aggregateRoot); } } finally { if (domainRepository != null) { _domainRepositoryResolver.Release(domainRepository); } } }
public async Task <CommandResult> HandleAsync(ICommandHandlingContext <CreateInventoryMasterCommand> context) { var db = context.GetMe <IDomainStore>(); var command = context.Command; var master = new InventoryMaster { GeneralNomenclature = command.GeneralNomenclature, IsGArmy = command.IsGArmy, LIN = command.LIN, Status = command.Status, TrackingType = command.TrackingType }; await db.SaveAsync(master); //want to track created event var usernameProvider = context.GetMe <IUsernameProvider>(); context.PublishEvent(new InventoryMasterCreatedEvent( master.AggregateRootId, command.LIN, command.GeneralNomenclature, command.IsGArmy, command.TrackingType, usernameProvider.GetUsername())); return(CommandResult.Success()); }
private void ExecuteTheCommandHandler(ICommandHandlingContext <ICommand> handlingContext) { var handleMethod = GetTheHandleMethod(); var commandHandler = CreateTheCommandHandler(); handleMethod.Invoke(commandHandler, new object[] { handlingContext }); }
Task IHandleCommands <TCommand> .Handle(ICommandHandlingContext <TCommand> handlingContext) { context = handlingContext; Validate(handlingContext.Command); return(Handle(handlingContext.Command)); }
public async Task <CommandResult> HandleAsync(ICommandHandlingContext <DeleteInventoryMasterCommand> context) { var db = context.GetMe <IDomainStore>(); var command = context.Command; await db.DeleteAsync <InventoryMaster>(command.AggregateRootId); return(CommandResult.Success()); }
void IHandleCommands <TCommand> .Handle(ICommandHandlingContext <TCommand> handlingContext) { var command = handlingContext.Command; ValidateTheCommand(handlingContext, command); var domainRepository = GetTheDomainRepository(); var aggregateRoot = domainRepository.GetById <TAggregateRoot>(command.AggregateRootId); Handle(command, aggregateRoot); domainRepository.Save(aggregateRoot); }
private void ExecuteTheCommandHandler(ICommandHandlingContext <ICommand> handlingContext) { var handleMethod = GetTheHandleMethod(); var commandHandler = CreateTheCommandHandler(); try { handleMethod.Invoke(commandHandler, new object[] { handlingContext }); } catch (TargetInvocationException ex) { throw new Exception( string.Format("Command handler '{0}' for '{1}' failed. Inspect inner exception.", commandHandler.GetType().Name, handlingContext.Command.GetType().Name), ex.InnerException); } }
public Task HandleAsync( ICommandHandlingContext <LogInUser> context, CancellationToken cancellationToken = default) { ExecutionContext.CurrentUser = new User { Name = context.Command.Name, LoggedInAt = DateTime.Now }; _eventDispatcher.DispatchAsync(new UserWasLoggedIn( ExecutionContext.CurrentUser.Name, ExecutionContext.CurrentUser.LoggedInAt), cancellationToken); return(Task.CompletedTask); }
private async Task ExecuteTheCommandHandler(IUnityContainer container, ICommandHandlingContext <ICommand> handlingContext) { var handleMethod = GetTheHandleMethod(); var commandHandler = container.Resolve(commandHandlerType); try { await(Task) handleMethod.Invoke(commandHandler, new object[] { handlingContext }); return; } catch (TargetInvocationException ex) { throw new CommandHandlerInvocationException( string.Format("Command handler '{0}' for '{1}' failed. Inspect inner exception.", commandHandler.GetType().Name, handlingContext.Command.GetType().Name), ex.InnerException) { HandlingContext = handlingContext }; } }
public async Task <CommandResult> HandleAsync(ICommandHandlingContext <UpdateInventoryMasterCommand> context) { var db = context.GetMe <IDomainStore>(); var command = context.Command; var usernameProvider = context.GetMe <IUsernameProvider>(); var master = await db.GetExistingByIdAsync <InventoryMaster>(command.AggregateRootId); //i want to see when the lin changes if (master.LIN != command.LIN) { context.PublishEvent(new LinChangedEvent( master.AggregateRootId, command.LIN, usernameProvider.GetUsername())); } master.LIN = command.LIN; master.GeneralNomenclature = command.GeneralNomenclature; master.IsGArmy = command.IsGArmy; master.TrackingType = command.TrackingType; master.Status = command.Status; await db.SaveAsync(master); //want to track created event context.PublishEvent(new InventoryMasterUpdatedEvent( master.AggregateRootId, command.LIN, command.GeneralNomenclature, command.IsGArmy, command.TrackingType, usernameProvider.GetUsername())); return(CommandResult.Success()); }
void IHandleCommands <TCommand> .Handle(ICommandHandlingContext <TCommand> handlingContext) { context = handlingContext; Handle(handlingContext.Command); }
public Task HandleAsync(ICommandHandlingContext <SomeBuggyCommand> context, CancellationToken cancellationToken = default) { throw new InvalidOperationException(context.Command.ExceptionText); }
public Task <string> HandleAsync( ICommandHandlingContext <SomeCommandWithResult> context, CancellationToken cancellationToken = default) { return(Task.FromResult(context.Command.SomeProperty)); }
public Task HandleAsync( ICommandHandlingContext <SomeCommand> context, CancellationToken cancellationToken = default) { return(Task.CompletedTask); }
public void Handle(ICommandHandlingContext <MyTest2Command> handlingContext) { handlingContext.Return(handlingContext.Command.ReturnValue); }
public Task Invoke(ICommandHandlingContext context, object next) { return(Task.CompletedTask); }
public void Invoke(ICommandHandlingContext context, IPipe <ICommandHandlingContext> next) { }
public void Handle(ICommandHandlingContext <RegisterUserCommand> handlingContext, Exception exception) { }
public Task <Either <string, ValidationState> > HandleAsync( ICommandHandlingContext <TestCommandWithEitherResult> context, CancellationToken cancellationToken = default) { return(Task.FromResult(new Either <string, ValidationState>("Some result"))); }
public Task <string> HandleAsync( ICommandHandlingContext <TestCommand> context, CancellationToken cancellationToken = default) { return(Task.FromResult("Some result")); }
public async Task <Notification> ValidateAsync(ICommandHandlingContext <UpdateInventoryMasterCommand> context) { return(await EnsureUniqueLIN(context.Command.AggregateRootId, context.Command.LIN, context.GetMe <IQueryBus>())); }
private void ValidateTheCommand(ICommandHandlingContext <TCommand> handlingContext, TCommand command, TAggregateRoot aggregateRoot) { ValidationResult = ValidateCommand(command, aggregateRoot); handlingContext.Return(ValidationResult); }
private void ValidateTheCommand(ICommandHandlingContext <TCommand> handlingContext, TCommand command) { ValidationResult = ValidateCommand(command); handlingContext.Return(ValidationResult); }