public async Task <IActionResult> Edit(int id, [Bind("DepartmentID,DepartmentName")] Department department)
{
if (id != department.DepartmentID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
var command = new EditDepartmentCommand(department);
var handler = CommandHandlerFactory.Build(command);
handler.Execute(_context);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DepartmentExists(department.DepartmentID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(department));
}
public async Task <IActionResult> Edit(int id, [Bind("EmployeeID,DepartmentID,Surname,Name,Patronymic,DateOfBirth")] Employee employee)
{
if (id != employee.EmployeeID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
var command = new EditEmployeeCommand(employee);
var handler = CommandHandlerFactory.Build(command);
handler.Execute(_context);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EmployeeExists(employee.EmployeeID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["DepartmentID"] = new SelectList(_context.Department, "DepartmentID", "DepartmentID", employee.DepartmentID);
return(View(employee));
}
private static void PerformCommand()
{
if (CommandIsNotAllowed())
{
return;
}
CommandExecutionResult result = null;
try
{
result = CommandHandlerFactory
.Create(_executionContext.Command.CommandType)
.Execute(_executionContext.Command.Parameters,
_executionContext.CurrentScreen.Model);
}
catch (Exception exception)
{
ExceptionScreen(exception);
return;
}
_executionContext.CurrentScreen = result.NextScreenType.HasValue
? ScreenFactory.CreateScreen(_render, result.NextScreenType.Value, result.Model)
: null;
_executionContext.Command = null;
_render.Clear();
}
protected Spesification()
{
this.eventStore = new TestEventStore();
var commandHandlerFactory = new CommandHandlerFactory(this.eventStore);
this.app = new CommandDispatcher(commandHandlerFactory);
}
public async Task SendAsync <T>(T command) where T : Command
{
UnitOfWork = _unitOfWorkManager.Build();
_logger.LogDebug("EXECUTE> _unitOfWorkManager.Build()");
var commandHandler = CommandHandlerFactory.GetHandler <T>();
try
{
UnitOfWork.Begin(new UnitOfWorkOption()
{
IsolationLevel = IsolationLevel.ReadCommitted
});
await commandHandler.ExecuteAsync(command);
await UnitOfWork.CommitAsync();
}
catch (Exception ex)
{
//log
throw ex;
}
////处理事件，保证最终一致性
//if (command.Events != null && command.Events.Any())
//{
// var eventPublisher = AppConfig.Current.IoCManager.GetService<IEventPublisher>();
// await eventPublisher.PublishAsync(command.Events);
//}
_logger.LogDebug("EXECUTE> UnitOfWork.CommitAsync()");
}
public static IEnumerable <ICommand> NextCommand()
{
while (true)
{
yield return(CommandHandlerFactory.Create(Output.ReadLine()));
}
}
public void CreateHelpHandler_ReturnHelpHandler()
{
var handlerFactory = new CommandHandlerFactory();
var handler = (IMethodName)handlerFactory.CreateHandlerForCommand("\\help");
Assert.Equal(nameof(CommandController.ShowHelp), handler.MethodName);
}
public void ShouldLogFailedCommand()
{
var testCommand = new EnterGameResultsCommand();
testCommand.GameDate = DateTime.Now.AddDays(-2);
testCommand.CommandId = Guid.NewGuid();
testCommand.GameId = Guid.NewGuid();
testCommand.IPAddress = "12.34.56.78";
testCommand.User = "******";
testCommand.Timestamp = DateTime.Now;
var newPlayerA = new EnterGameResultsCommand.GamePlayer();
newPlayerA.PlayerName = "Dylan Smith";
newPlayerA.Placing = 1;
newPlayerA.Winnings = 120;
newPlayerA.PayIn = 60;
var newPlayerB = new EnterGameResultsCommand.GamePlayer();
newPlayerB.PlayerName = "Homer Simpson";
newPlayerB.Placing = 2;
newPlayerB.Winnings = 0;
newPlayerB.PayIn = 60;
var players = new List <EnterGameResultsCommand.GamePlayer>();
players.Add(newPlayerA);
players.Add(newPlayerB);
testCommand.Players = players;
var mockCommandRepository = new Mock <ICommandRepository>();
var mockEventRepository = new Mock <IEventRepository>();
var mockQueryService = new Mock <IQueryService>();
var sut = new CommandHandlerFactory(
mockEventRepository.Object,
mockQueryService.Object,
mockCommandRepository.Object);
var ex = new ArgumentException("foo");
mockEventRepository.Setup(x => x.PublishEvents(It.IsAny <IAggregateRoot>(), testCommand)).Throws(ex);
try
{
sut.ExecuteCommand(testCommand);
}
catch
{
// eat all exceptions
}
mockCommandRepository.Verify(x => x.LogCommand(testCommand));
mockCommandRepository.Verify(x => x.LogFailedCommand(testCommand, ex));
}
public void CreatesHandler()
{
object testResult = new object();
CommandHandlerFactory testSubject = new CommandHandlerFactory(t => testResult);
object result = testSubject.Create(typeof(string));
Assert.Same(testResult, result);
}
public void RunTest(IEnumerable <ICommand> commands)
{
Setup();
var repository = new FakeEventRepository();
repository.InitialEvents = Given();
var queryDataStore = new FakeQueryDataStore();
var queryService = new QueryHandlerFactory(queryDataStore);
var commandRepository = new Mock <ICommandRepository>();
HandleEvents(repository.InitialEvents, queryDataStore);
Exception caughtException = null;
var commandHandlerFactory = new CommandHandlerFactory(repository, queryService, commandRepository.Object);
var generatedEvents = new List <IEvent>();
foreach (var command in commands)
{
try
{
commandHandlerFactory.ExecuteCommand(command);
}
catch (Exception e)
{
if (ExpectedException() == null)
{
throw;
}
caughtException = e;
}
HandleEvents(repository.EventList, queryDataStore);
generatedEvents.AddRange(repository.EventList);
repository.InitialEvents = new List <IEvent>(repository.InitialEvents).Concat(repository.EventList).ToList();
repository.EventList.Clear();
}
if (caughtException != null || ExpectedException() != null)
{
if (caughtException != null && ExpectedException() != null)
{
Assert.AreEqual(ExpectedException().GetType(), caughtException.GetType());
}
else
{
Assert.Fail("There was an Expected Exception but none was thrown.");
}
}
ValidateExpectedEvents(ExpectedEvents(), generatedEvents);
}
public void GetHandler_ForPostingCommand_UsingTestData_ReturnsHandler(string command)
{
var handler = new CommandHandlerFactory
(
MappingTestData.Main.Data
).GetHandler(command);
Assert.NotNull(handler);
Assert.IsAssignableFrom <PostingHandler>(handler);
}
public void GetHandler_ForExistantCommand_ReturnsHandler(string command, Type commandHandlerType)
{
var handler = new CommandHandlerFactory
(
MappingTestData.Main.Data
).GetHandler(command);
Assert.NotNull(handler);
Assert.IsType(commandHandlerType, handler);
}
/// <summary>
/// The Send.
/// </summary>
/// <typeparam name="TCommand">.</typeparam>
/// <typeparam name="TCommandResult">.</typeparam>
/// <param name="command">.</param>
/// <returns>.</returns>
public SimpleResponse <TCommandResult> Send <TCommand, TCommandResult>
(TCommand command)
where TCommand : class, ICommand <TCommandResult>
where TCommandResult : class, ICommandResult, new()
{
var handler =
CommandHandlerFactory.GetCommandHandler <TCommand, TCommandResult>();
var valid = handler.Validate(command);
if (valid.ResponseCode < 0)
{
return(new SimpleResponse <TCommandResult>
{
ResponseCode = valid.ResponseCode,
ResponseMessage = valid.ResponseMessage,
RCode = valid.RCode
});
}
var authorize = handler.Authorize(command);
if (authorize.ResponseCode < 0)
{
return(new SimpleResponse <TCommandResult>
{
ResponseCode = authorize.ResponseCode,
ResponseMessage = authorize.ResponseMessage,
RCode = authorize.RCode
});
}
// Get Handle method custom attributes for Parameter Validation.
// (handler.GetType().GetMethod("Handle").GetCustomAttributes(true)?? new object[0])
// handler.GetType().GetMethod("Handle").GetParameters()
// command.Validate()
/*
* var validationResult = command.Validate();
* if (validationResult.HasError)
* {
* response.Data = new TCommandResult();
* response.ResponseCode = -200;
#if DEBUG
* response.ResponseMessage = validationResult.AllDevValidationMessages;
#else
* response.ResponseMessage = validationResult.AllValidationMessages;
#endif
*
* return response;
* }
*/
var commandResult = handler.Handle(command);
return(commandResult);
}
public void GetHandler_ForNonExistantCommand_ReturnsNull()
{
const string command = "James >> Push It Up!";
var handler = new CommandHandlerFactory
(
MappingTestData.Empty.Data //TODO: Use Main Mapping test data with correct RegEx
).GetHandler(command);
Assert.Null(handler);
}
public static CommandHandlerFactory NewCommandHandlerFactory(Func <IRepository> repositoryProvider)
{
var commandHandlerFactor = new CommandHandlerFactory();
commandHandlerFactor.RegisterFactory(
() => new CustomerCommandHandler(repositoryProvider()),
typeof(CreateNewCustomer),
typeof(UpdateCustomer),
typeof(RemoveCustomer));
return(commandHandlerFactor);
}
public static CommandHandlerFactory NewCommandHandlerFactory(Func <IRepository> repositoryProvider)
{
var commandHandlerFactor = new CommandHandlerFactory();
commandHandlerFactor.RegisterFactory(
() => new ShipmentCommandHandler(repositoryProvider()),
typeof(CreateShipment),
typeof(StartShipment),
typeof(DeliverShipment));
return(commandHandlerFactor);
}
private async Task HandleEvent(EventContext eventContext)
{
var action = (string)eventContext.WebHookEvent.GetPayload().action;
var body = (string)eventContext.WebHookEvent.GetPayload().issue.body;
body = body.Trim();
var parts = body.Split(' ').Select(q => q.Trim()).ToArray();
var authorAssociation = (string)eventContext.WebHookEvent.GetPayload().issue.author_association;
var commandHandler = CommandHandlerFactory.GetHandler(action, parts, authorAssociation, eventContext);
await commandHandler.Execute(action, parts, authorAssociation, eventContext, _SophiaDbContext);
}
public static Implementation.Application Bootstrap()
{
var store = new InMemoryEventStore();
var handlerFactory = new CommandHandlerFactory(store);
var dispatcher = new CommandDispatcher(handlerFactory);
var shoppingCartContext = new ShoppingCartContext();
var eventHandlerFactory = new EventHandlerFactory(store, dispatcher, shoppingCartContext);
var eventDispatcher = new EventDispatcher(eventHandlerFactory);
var eventProcessor = new EventProcessor(store, eventDispatcher);
return(new Implementation.Application(shoppingCartContext, dispatcher, eventProcessor));
}
public async Task <IActionResult> Create([Bind("DepartmentID,DepartmentName")] Department department)
{
if (ModelState.IsValid)
{
var command = new CreateDepartmentCommand(department);
var handler = CommandHandlerFactory.Build(command);
handler.Execute(_context);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(department));
}
public void Should_get_handler_from_factory()
{
var serviceLocator = Substitute.For <IServiceLocator>();
serviceLocator.Resolve <TestCommandHandler>()
.Returns(new TestCommandHandler());
var handlerFactory = new CommandHandlerFactory(serviceLocator);
var handler = handlerFactory.CreateHandler(new TestCommand());
handler.Should().NotBeOfType <TestCommandHandler>();
}
public async Task <IActionResult> Create([Bind("EmployeeID,DepartmentID,Surname,Name,Patronymic,DateOfBirth")] Employee employee)
{
if (ModelState.IsValid)
{
var command = new CreateEmployeeCommand(employee);
var handler = CommandHandlerFactory.Build(command);
handler.Execute(_context);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["DepartmentID"] = new SelectList(_context.Department, "DepartmentID", "DepartmentID", employee.DepartmentID);
return(View(employee));
}
public void RunTest(ICommand command)
{
Setup();
var repository = new FakeEventRepository();
repository.InitialEvents = Given();
var queryDataStore = new FakeQueryDataStore();
var queryService = new QueryHandlerFactory(queryDataStore);
var commandRepository = new Mock <ICommandRepository>();
HandleEvents(repository.InitialEvents, queryDataStore);
Exception caughtException = null;
var commandHandlerFactory = new CommandHandlerFactory(repository, queryService, commandRepository.Object);
try
{
commandHandlerFactory.ExecuteCommand(command);
}
catch (Exception e)
{
if (ExpectedException() == null)
{
throw;
}
caughtException = e;
}
if (caughtException != null || ExpectedException() != null)
{
if (caughtException != null && ExpectedException() != null)
{
Assert.AreEqual(ExpectedException().GetType(), caughtException.GetType());
}
else
{
Assert.Fail("There was an Expected Exception but none was thrown.");
}
}
ValidateExpectedEvents(ExpectedEvents(), repository.EventList);
}
public void RunTest(ICommand command)
{
Setup();
var repository = new FakeEventRepository();
repository.InitialEvents = Given();
var queryDataStore = new FakeQueryDataStore();
var queryService = new QueryHandler(queryDataStore);
var commandRepository = new Mock<ICommandRepository>();
HandleEvents(repository.InitialEvents, queryDataStore);
Exception caughtException = null;
var commandHandlerFactory = new CommandHandlerFactory(repository, queryService, commandRepository.Object);
try
{
commandHandlerFactory.ExecuteCommand(command);
}
catch (Exception e)
{
if (ExpectedException() == null)
{
throw;
}
caughtException = e;
}
if (caughtException != null || ExpectedException() != null)
{
if (caughtException != null && ExpectedException() != null)
{
Assert.AreEqual(ExpectedException().GetType(), caughtException.GetType());
}
else
{
Assert.Fail("There was an Expected Exception but none was thrown.");
}
}
ValidateExpectedEvents(ExpectedEvents(), repository.EventList);
}
public void ShouldLogCommand()
{
var testCommand = new EnterGameResultsCommand();
testCommand.GameDate = DateTime.Now.AddDays(-2);
testCommand.CommandId = Guid.NewGuid();
testCommand.GameId = Guid.NewGuid();
testCommand.IPAddress = "12.34.56.78";
testCommand.User = "******";
testCommand.Timestamp = DateTime.Now;
var newPlayerA = new EnterGameResultsCommand.GamePlayer();
newPlayerA.PlayerName = "Dylan Smith";
newPlayerA.Placing = 1;
newPlayerA.Winnings = 120;
newPlayerA.PayIn = 60;
var newPlayerB = new EnterGameResultsCommand.GamePlayer();
newPlayerB.PlayerName = "Homer Simpson";
newPlayerB.Placing = 2;
newPlayerB.Winnings = 0;
newPlayerB.PayIn = 60;
var players = new List <EnterGameResultsCommand.GamePlayer>();
players.Add(newPlayerA);
players.Add(newPlayerB);
testCommand.Players = players;
var mockCommandRepository = new Mock <ICommandRepository>();
var sut = new CommandHandlerFactory(
new Mock <IEventRepository>().Object,
new Mock <IQueryService>().Object,
mockCommandRepository.Object);
sut.ExecuteCommand(testCommand);
mockCommandRepository.Verify(x => x.LogCommand(testCommand));
}
public void CommandHandlerShouldBeResolved()
{
//Given
var commandHandlerFactory = new CommandHandlerFactory();
var mockCommandHandler = new MockCommandHandler(new List <string>());
var updateMockCommandHandler = new UpdateMockCommandHandler();
//When
commandHandlerFactory.Register <CreateAMockCommand>(mockCommandHandler);
commandHandlerFactory.Register <UpdateMockCommand>(updateMockCommandHandler);
var first_CommandHandler = commandHandlerFactory.Resolved <CreateAMockCommand>();
var second_commandHandler = commandHandlerFactory.Resolved <UpdateMockCommand>();
//Then
Assert.IsType <MockCommandHandler>(first_CommandHandler);
Assert.IsType <UpdateMockCommandHandler>(second_commandHandler);
}
public void Gives_handler_that_can_handle_command(CommandHandlerFactory commandHandlerFactory,
ICommandHandler commandHandler)
{
"Given I have a 2 command handlers one of which can handle a dummy command"
._(
() =>
commandHandlerFactory =
new CommandHandlerFactory(new ICommandHandler[]
{
new OtherCommandHandler(),
new DummyCommandHandler()
}));
"When I create a command handler for a dummy command"
._(() => commandHandler = commandHandlerFactory.Create(new DummyCommand()));
"Then the dummy command handler is returned"
._(() => commandHandler.Should().BeOfType <DummyCommandHandler>());
}
static void Main(string[] args)
{
var command = new Command();
bool isHelp = args.Any(x => x == "-?");
var success = Parser.Default.ParseArguments(args, command);
if (!success || isHelp)
{
if (!isHelp && args.Length > 0)
{
Console.Error.WriteLine("error parsing command line");
}
}
var factory = new CommandHandlerFactory();
var commandHandler = factory.Create(command);
commandHandler.Execute(command);
}
public static CommandHandlerFactory NewCommandHandlerFactory(Func <IRepository> repositoryProvider)
{
var commandHandlerFactor = new CommandHandlerFactory();
commandHandlerFactor.RegisterFactory(
() => new ShoppingCartCommandHandler(repositoryProvider()),
typeof(CreateNewCart),
typeof(AddProductToCart),
typeof(RemoveProductFromCart),
typeof(EmptyCart),
typeof(Checkout));
commandHandlerFactor.RegisterFactory(
() => new OrderCommandHandler(repositoryProvider()),
typeof(PlaceOrder),
typeof(PayForOrder),
typeof(ProvideShippingAddress),
typeof(CompleteOrder));
return(commandHandlerFactor);
}
public void GetHandler_UsingConfigurationData_ReturnsHandler(string command, Type commandHandlerType)
{
var handler = new CommandHandlerFactory
(
new CommandHandlerMappingFactory
(
Configuration
.Development
.ConfigurationRoot
.GetSection(Resources.CommandHandlerMappingsConfigurationKey)
.Get <IEnumerable <CommandHandlerMappingOptions> >(),
new UserRepository
(
new Dictionary <string, IUser>()
)
)
.CreateMappings()
).GetHandler(command);
Assert.NotNull(handler);
Assert.IsAssignableFrom(commandHandlerType, handler);
}
public void ShouldLogCommand()
{
var testCommand = new EnterGameResultsCommand();
testCommand.GameDate = DateTime.Now.AddDays(-2);
testCommand.CommandId = Guid.NewGuid();
testCommand.GameId = Guid.NewGuid();
testCommand.IPAddress = "12.34.56.78";
testCommand.User = "******";
testCommand.Timestamp = DateTime.Now;
var newPlayerA = new EnterGameResultsCommand.GamePlayer();
newPlayerA.PlayerName = "Dylan Smith";
newPlayerA.Placing = 1;
newPlayerA.Winnings = 120;
newPlayerA.PayIn = 60;
var newPlayerB = new EnterGameResultsCommand.GamePlayer();
newPlayerB.PlayerName = "Homer Simpson";
newPlayerB.Placing = 2;
newPlayerB.Winnings = 0;
newPlayerB.PayIn = 60;
var players = new List<EnterGameResultsCommand.GamePlayer>();
players.Add(newPlayerA);
players.Add(newPlayerB);
testCommand.Players = players;
var mockCommandRepository = new Mock<ICommandRepository>();
var sut = new CommandHandlerFactory(
new Mock<IEventRepository>().Object,
new Mock<IQueryService>().Object,
mockCommandRepository.Object);
sut.ExecuteCommand(testCommand);
mockCommandRepository.Verify(x => x.LogCommand(testCommand));
}
public void Send <T>(T command) where T : Command
{
var commandHandler = CommandHandlerFactory.GetHandler <T>();
try
{
UnitOfWork.BeginTransaction(new UnitOfWorkOptions()
{
IsolationLevel = IsolationLevel.ReadCommitted
});
//translation.open()
commandHandler.Execute(command);
UnitOfWork.Commit();
}
catch (Exception ex)
{
//log(ex)
//db.RollBack()
UnitOfWork.RollBack();
throw ex;
}
}
public void ShouldLogFailedCommand()
{
var testCommand = new CreateGameCommand();
testCommand.GameDate = DateTime.Now.AddDays(-2);
testCommand.CommandId = Guid.NewGuid();
testCommand.GameId = Guid.NewGuid();
testCommand.IPAddress = "12.34.56.78";
testCommand.Timestamp = DateTime.Now;
var mockCommandRepository = new Mock <ICommandRepository>();
var mockEventRepository = new Mock <IEventRepository>();
var mockQueryService = new Mock <IQueryService>();
mockQueryService.Setup(q => q.Execute(It.IsAny <GetGameCountByDateQuery>())).Returns(0);
var sut = new CommandHandlerFactory(
mockEventRepository.Object,
mockQueryService.Object,
mockCommandRepository.Object);
var ex = new ArgumentException("foo");
mockEventRepository.Setup(x => x.PublishEvents(It.IsAny <IAggregateRoot>(), testCommand)).Throws(ex);
try
{
sut.ExecuteCommand(testCommand);
}
catch
{
// eat all exceptions
}
mockCommandRepository.Verify(x => x.LogCommand(testCommand));
mockCommandRepository.Verify(x => x.LogFailedCommand(testCommand, ex));
}
public void ShouldLogFailedCommand()
{
var testCommand = new EnterGameResultsCommand();
testCommand.GameDate = DateTime.Now.AddDays(-2);
testCommand.CommandId = Guid.NewGuid();
testCommand.GameId = Guid.NewGuid();
testCommand.IPAddress = "12.34.56.78";
testCommand.User = "******";
testCommand.Timestamp = DateTime.Now;
var newPlayerA = new EnterGameResultsCommand.GamePlayer();
newPlayerA.PlayerName = "Dylan Smith";
newPlayerA.Placing = 1;
newPlayerA.Winnings = 120;
newPlayerA.PayIn = 60;
var newPlayerB = new EnterGameResultsCommand.GamePlayer();
newPlayerB.PlayerName = "Homer Simpson";
newPlayerB.Placing = 2;
newPlayerB.Winnings = 0;
newPlayerB.PayIn = 60;
var players = new List<EnterGameResultsCommand.GamePlayer>();
players.Add(newPlayerA);
players.Add(newPlayerB);
testCommand.Players = players;
var mockCommandRepository = new Mock<ICommandRepository>();
var mockEventRepository = new Mock<IEventRepository>();
var mockQueryService = new Mock<IQueryService>();
var sut = new CommandHandlerFactory(
mockEventRepository.Object,
mockQueryService.Object,
mockCommandRepository.Object);
var ex = new ArgumentException("foo");
mockEventRepository.Setup(x => x.PublishEvents(It.IsAny<IAggregateRoot>(), testCommand)).Throws(ex);
try
{
sut.ExecuteCommand(testCommand);
}
catch
{
// eat all exceptions
}
mockCommandRepository.Verify(x => x.LogCommand(testCommand));
mockCommandRepository.Verify(x => x.LogFailedCommand(testCommand, ex));
}
