public async Task ClearUncommittedEventsFromAggregate(IAggregateRoot <TestAggregate> aggregateRoot, EventStoreRepository sut) { await sut.SaveAsync(aggregateRoot); aggregateRoot.Received(1).ClearUncommittedEvents(); }
static void Main(string[] args) { // docker run --name eventstore-node -it --rm -p 2113:2113 -p 1113:1113 -v ~/data/eventstore/ESData:/var/lib/eventstore -v ~/data/eventstore/logs:/var/log/eventstore eventstore/eventstore --run-projections=all Console.WriteLine("Hello EventstoreConsole!"); var uri = new Uri("tcp://localhost:1113"); try { var connection = EventStoreConnection.Create(uri); System.Console.WriteLine("Connect to Eventstore..."); connection.ConnectAsync().Wait(); System.Console.WriteLine("Connected!"); var repo = new EventStoreRepository(connection); // OrganizationTest(repo); WriteByEventType(repo); connection.Close(); } catch (Exception ex) { Console.WriteLine(ex.Message); } }
public async Task GetByIdAsyncWithEventsShouldReturnTheCurrentStateOfTheAggregate() { //Arrange #region mock of DataBaseContext , mock of IDomainEventRebuilder and mock of moqInvoker var aggregateId = Guid.NewGuid(); var optionsBuilder = new DbContextOptionsBuilder <DataBaseContext>(); optionsBuilder.UseInMemoryDatabase("FakeInMemoryData"); var moqContext = new DataBaseContext(optionsBuilder.Options); moqContext.Database.EnsureCreated(); var obj = new EventOject(aggregateId, "Dupont", "45 av charles degaulle paris, france"); var type = obj.GetType().AssemblyQualifiedName; var json = @" { 'FullName':'Dupont', 'Adresse':'45 av charles degaulle paris, france' }"; moqContext.EventStore.Add(new EventStore(aggregateId, 1, "2@735f8407-16be-44b5-be96-2bab582b5298", type, DateTime.Now, json)); moqContext.SaveChanges(); Mock <IDomainEventRebuilder> moqDomainEventRebuilder = new Mock <IDomainEventRebuilder>(); moqDomainEventRebuilder.Setup(m => m.RebuildDomainEvents(It.IsAny <IEnumerable <EventStore> >())) .Returns(new List <Event> { obj }); var aggregate = (StubAggregate)typeof(StubAggregate) .GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[0], new ParameterModifier[0]) ?.Invoke(new object[0]); var moqInvoker = new Mock <IInvoker <StubAggregate> >(); moqInvoker.Setup(i => i.CreateInstanceOfAggregateRoot <StubAggregate>()).Returns(aggregate); #endregion mock of DataBaseContext , mock of IDomainEventRebuilder and mock of moqInvoker var sut = new EventStoreRepository <StubAggregate>(moqContext, moqInvoker.Object, moqDomainEventRebuilder.Object); //Act var result = await sut.GetByIdAsync <StubAggregate>(aggregateId); moqContext.Dispose(); //Assert Assert.NotNull(aggregate); Assert.Equal(aggregate, result); Assert.Equal(aggregateId, aggregate.Id); Assert.Equal(obj.FullName, aggregate.FullName); Assert.Equal(obj.Adresse, aggregate.Adresse); }
public ServiceBusRegistry() { For <IReportingRepository <PatientDto> >() .Use <SqlReportingRepository>() .Ctor <string>() .Is(AppConfig.PatientDBEventStoreEntities); var bus = new InProcessBus(); For <IBus>().Use(bus); var eventStore = GetInitializedEventStore(bus); var repository = new EventStoreRepository(eventStore, new AggregateFactory(), new ConflictDetector()); For <IStoreEvents>() .Use(eventStore); For <IRepository>() .Use(repository); For <IHandles <CreatePatientCommand> >() .Use <CreatePatientCommandHandler>(); For <IHandles <ChangePatientNameCommand> >() .Use <ChangePatientNameCommandHandler>(); }
public static void Main(string[] args) { var bus = BusSetup.StartWith <Conservative>() .Apply <FlexibleSubscribeAdapter>(a => { a.ByInterface(typeof(IEventHandler <>)); a.ByInterface(typeof(ICommandHandler <>)); }).Construct(); var someAwesomeUi = new SomeAwesomeUi(bus); using (store = WireupEventStore(bus)) { var repository = new EventStoreRepository(store, new AggregateFactory(), new ConflictDetector()); var handler = new CreateAccountCommandHandler(repository); var handler2 = new CloseAccountCommandHandler(repository); bus.Subscribe(handler); bus.Subscribe(handler2); bus.Subscribe(new KaChingNotifier()); bus.Subscribe(new OmgSadnessNotifier()); someAwesomeUi.CreateNewAccount(AggregateId, "Luiz", "@luizdamim"); someAwesomeUi.CloseAccount(AggregateId); } Console.ReadLine(); }
public static EventStoreStatelessActorBuilder <TActor, TRegistry> Create( ClusterVNode clusterVNode, ConnectionSettings connectionSettings, IActorConfiguration actorConfiguration, ILoggerFactory?loggerFactory = null, Action <IEventStoreRepositoryConfiguration>?getEventStoreRepositoryConfiguration = null) { var connection = EmbeddedEventStoreConnection.Create(clusterVNode, connectionSettings); loggerFactory ??= new DummyLoggerFactory(); var eventStoreRepositoryConfiguration = new EventStoreRepositoryConfiguration(); getEventStoreRepositoryConfiguration?.Invoke(eventStoreRepositoryConfiguration); var connectionStatusMonitor = new EventStoreConnectionStatusMonitor(connection, loggerFactory); var eventStoreRepository = new EventStoreRepository( eventStoreRepositoryConfiguration, connection, connectionStatusMonitor, loggerFactory); var eventStoreStatelessActorBuilder = new EventStoreStatelessActorBuilder <TActor, TRegistry>(actorConfiguration, eventStoreRepository, connectionStatusMonitor, loggerFactory); return(eventStoreStatelessActorBuilder); }
static void Main(string[] args) { var eventStoreConfiguration = new EventStoreConfiguration { MongoDbConnectionString = "mongodb://*****:*****@cluster0-shard-00-00-5pgij.mongodb.net:27017,cluster0-shard-00-01-5pgij.mongodb.net:27017,cluster0-shard-00-02-5pgij.mongodb.net:27017/test?ssl=true&replicaSet=Cluster0-shard-0&authSource=admin", EventTypeHeader = "FourSolidEventName", AggregateTypeHeader = "FourSolidAggregateName" }; var eventDataFactory = new EventDataFactory(eventStoreConfiguration); var eventStoreRepository = new EventStoreRepository(eventStoreConfiguration, eventDataFactory); var deviceGuid = Guid.NewGuid(); var device = Device.CreateDevice(deviceGuid, "AB1234DE", "AB1234DE", DateTime.UtcNow); eventStoreRepository.SaveAsync(device, Guid.NewGuid(), d => { }).GetAwaiter().GetResult(); device = eventStoreRepository.GetByIdAsync <Device>(deviceGuid).GetAwaiter().GetResult(); device.UpdateSerialNumber("BC2345EF"); eventStoreRepository.SaveAsync(device, Guid.NewGuid(), d => { }).GetAwaiter().GetResult(); Console.WriteLine($"Device Id: {device.Id}"); Console.WriteLine($"Serial Number: {device.GetSerialNumber()}"); Console.ReadLine(); }
public async Task <TAggregate> GetByIdAsync <TAggregate>(string bucketId, Guid id, int version) where TAggregate : class, IAggregate { var aggregate = EventStoreRepository.ConstructAggregate <TAggregate>(); await Task.Run(() => this._givenEvents.ForEach(aggregate.ApplyEvent)); return(aggregate); }
private static void OrganizationTest(EventStoreRepository repo) { var organizationId = Guid.NewGuid(); System.Console.WriteLine("Enter organization name:"); var orgname = Console.ReadLine(); var orgCreatec = new OrganizationCreated { Name = orgname }; repo.WriteEvents(new AggregateKey(typeof(Organization), organizationId), new[] { orgCreatec }); string newName = null; do { var history = repo.ReadEvents(new AggregateKey(typeof(Organization), organizationId)); var organization = new Organization(organizationId, history); System.Console.WriteLine(""); System.Console.WriteLine("Organization " + organization.Name); System.Console.WriteLine("Rename: (q to exit)"); newName = Console.ReadLine(); if (!string.IsNullOrWhiteSpace(newName.Replace("q", ""))) { organization.Rename(newName); organization.Save(repo); } }while (newName != "q"); }
public async Task GetByIdAsyncWithoutEventsShouldReturnEmptyList() { //Arrange var optionsBuilder = new DbContextOptionsBuilder <DataBaseContext>(); optionsBuilder.UseInMemoryDatabase("FakeInMemoryData"); var moqContext = new DataBaseContext(optionsBuilder.Options); moqContext.Database.EnsureCreated(); var aggregate = (StubAggregate)typeof(StubAggregate) .GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[0], new ParameterModifier[0]) ?.Invoke(new object[0]); var moqInvoker = new Mock <IInvoker <StubAggregate> >(); moqInvoker.Setup(i => i.CreateInstanceOfAggregateRoot <StubAggregate>()).Returns(aggregate); var sut = new EventStoreRepository <StubAggregate>(moqContext, moqInvoker.Object, It.IsAny <IDomainEventRebuilder>()); var aggregateId = Guid.NewGuid(); //Act var result = await sut.GetByIdAsync <StubAggregate>(aggregateId); //Assert Assert.Equal(aggregate, result); }
public async Task <HookResult> AppendAll(List <DomainEventBase> domainEvents) { var domainEventsFromHooks = new List <DomainEventBase>(); var enumerator = domainEvents.GetEnumerator(); for ( ; enumerator.MoveNext(); ) { var domainEvent = enumerator.Current; var domainHooks = DomainHooks.Where(hook => hook.EventType == domainEvent.GetType()); var enumeratorHook = domainHooks.GetEnumerator(); for ( ; enumeratorHook.MoveNext(); ) { var domainHook = enumeratorHook.Current; var validationResult = await domainHook.ExecuteSavely(domainEvent); if (!validationResult.Ok) { return(validationResult); } domainEventsFromHooks.AddRange(validationResult.DomainEvents); } } await EventStoreRepository.AddEvents(domainEvents); await EventStoreRepository.AddEvents(domainEventsFromHooks); return(HookResult.OkResult()); }
public void Install(IWindsorContainer container, IConfigurationStore store) { var eventStore = getInitializedEventStore(new DispatchCommits(container.Resolve<IServiceBus>())); container.Register(Component.For<IStoreEvents>().Instance(eventStore).LifeStyle.Singleton); var repository = new EventStoreRepository(eventStore, new AggregateFactory(), new ConflictDetector()); container.Register(Component.For<IRepository>().Instance(repository).LifeStyle.Singleton); }
public EventStoreRepositoryBuilder(EventStoreRepository eventStoreRepository) { _eventStoreRepository = eventStoreRepository; _nameSpaceBuilderUtil = new NameSpaceBuilderUtil(); _propertyBuilderUtil = new PropertyBuilderUtil(); _constructorBuilderUtil = new ConstructorBuilderUtil(); _classBuilderUtil = new ClassBuilderUtil(); }
public async Task Create() { EventStoreRepository sut = await GetSut(); var foo = new SampleDomainObject("a04s4ac4-16eb-4b6b-aeea-12b2e034a408"); foo.Add(); await sut.SaveAsync(foo); }
/// <summary> /// /// </summary> protected override void LazyInit(ref IStoreEvents storeEventsInstance, object lockObject) { base.LazyInit(ref storeEventsInstance, lockObject); if (_repository == null) { _repository = new EventStoreRepository(storeEventsInstance, new AggregateFactory(), new ConflictDetector()); } }
public static void ClassInitialise(TestContext context) { bus = new InProcessBus(DispatchStrategy.Asynchronous); store = Wireup.Init() .UsingInMemoryPersistence() .Build(); repository = new EventStoreRepository(store, new AggregateFactory(), new ConflictDetector()); }
public async Task ItCallsTheConnections() { var con = A.Fake <IEventStoreConnection>(); EventStoreRepository sut = GetSut("UnitTest", con); var domainObj = new SampleDomainObject("1"); await sut.SaveAsync(domainObj); }
public void Install(IWindsorContainer container, IConfigurationStore store) { var eventStore = getInitializedEventStore(new DispatchCommits(container.Resolve <IServiceBus>())); container.Register(Component.For <IStoreEvents>().Instance(eventStore).LifeStyle.Singleton); var repository = new EventStoreRepository(eventStore, new AggregateFactory(), new ConflictDetector()); container.Register(Component.For <IRepository>().Instance(repository).LifeStyle.Singleton); }
public static void Init() { var storeEvents = WireupEventStore(); var aggregateFactory = new AggregateFactory(); var conflictDetector = new ConflictDetector(); var eventRepository = new EventStoreRepository(storeEvents, aggregateFactory, conflictDetector); _commandHandlerService = new CommandHandlerService(); _commandHandlerService.InitHandlers(eventRepository); }
public async Task Update() { var id = "a04s4ac4-16eb-4b6b-aeea-12b2e034a408"; EventStoreRepository sut = await GetSut(); SampleDomainObject result = await sut.Get <SampleDomainObject>(id); result.Add(); await sut.SaveAsync(result); }
/// <summary>Gets the by identifier.</summary> /// <param name="identifier">The identifier.</param> /// <returns>A <see cref="SystemAccount" />.</returns> public SystemAccount GetByIdentifier(string identifier) { var eventStore = _eventStoreFactory.Build <SystemAccount> (); var commits = eventStore.Advanced.GetFrom(DateTime.MinValue); var systemAccountCreatedEvent = commits.SelectMany(c => c.Events) .FirstOrDefault(e => e.Body is SystemAccountCreatedEvent && (e.Body as SystemAccountCreatedEvent).Identifier == identifier); return(systemAccountCreatedEvent == null ? null : EventStoreRepository.GetByKey <SystemAccount> ((systemAccountCreatedEvent.Body as SystemAccountCreatedEvent).Key)); //TODO: See if there is a way to do this without hitting the event store twice. }
void WithEventstore(Action <IAggregateEventStore> work) { var switchboard = new Nuclear.Lazy.Switchboard(); IEventStoreConnection connection = EventStoreConnection.Create(new IPEndPoint(IPAddress.Loopback, 1113)); connection.ConnectAsync().Wait(); IAggregateEventStore eventstore = new EventStoreRepository(connection, switchboard); work(eventstore); connection.Close(); }
public async Task BuildRepositories(Protocol chosenProtocol = Protocol.Tcp) { protocol = chosenProtocol; EventReader = await ConfigureReader(); EventWriter = await ConfigureWriter(); repository = new EventStoreRepository <string, IHoldHigherOrder>(validator, configuration, EventReader, EventWriter, DateTimeProvider); readOnlyRepository = new EventStoreReadOnlyRepository <string, IHoldHigherOrder>(configuration, EventReader); }
public void Install(IWindsorContainer container, IConfigurationStore store) { //Bus var bus = new InProcessBus(container); container.Register(Component.For<IBus>().Instance(bus)); var eventStore = GetInitializedEventStore(bus); var repository = new EventStoreRepository(eventStore, new AggregateFactory(), new ConflictDetector()); container.Register(Component.For<IStoreEvents>().Instance(eventStore)); container.Register(Component.For<IRepository>().Instance(repository)); }
private void ConfigureHandlers() { var bus = new RabbitMqBus(RabbitHutch.CreateBus("host=localhost")); ServiceLocator.Bus = bus; //Should get this from a config setting instead of hardcoding it. var eventStoreConnection = EventStoreConnection.Create(new IPEndPoint(IPAddress.Loopback, 12900)); eventStoreConnection.ConnectAsync().Wait(); var repository = new EventStoreRepository(eventStoreConnection, bus); ServiceLocator.ProductCommands = new ProductCommandHandlers(repository); }
public async Task GetByIdAsyncWithBadAggregateIdShouldRaiseBadAggregateIdException() { //Arrange var moqDb = new Mock <DataBaseContext>(); var sut = new EventStoreRepository <StubAggregate>(moqDb.Object, It.IsAny <IInvoker <StubAggregate> >(), It.IsAny <IDomainEventRebuilder>()); var aggregateId = Guid.Empty; //Act //Assert await Assert.ThrowsAsync <BadAggregateIdException>(() => sut.GetByIdAsync <StubAggregate>(aggregateId)); }
public EventStoreRepositoryTests() { _testDbContext = new YSecTestEventStoreContext(); _events = GenerateEvents(); _testDbContext.Events.AddRange(_events); _testDbContext.SaveChanges(); _eventStoreRepository = new EventStoreRepository(_testDbContext); }
public void Setup() { var unitOfWorkMock = new Mock <IUnitOfWork>(); var unitOfWorkProviderMock = new Mock <IUnitOfWorkProvider>(); unitOfWorkProviderMock.Setup(u => u.GetCurrentUnitOfWork()).Returns(unitOfWorkMock.Object); _eventStoreRepository = new EventStoreRepository(new InMemoryEventStoreFactory(), new AggregateFactory(), new Mock <IDetectConflicts>().Object, unitOfWorkProviderMock.Object); }
public static void ClassInitialise(TestContext context) { bus = new InProcessBus(DispatchStrategy.Synchronous); client = new SomeAwesomeUi(bus); store = Wireup.Init().UsingInMemoryPersistence().Build(); var repository = new EventStoreRepository(store, new AggregateFactory(), new ConflictDetector()); var handler = new CreateAccountCommandHandler(repository); bus.Subscribe(handler); accountId = client.CreateNewAccount(); }
public void Reprioritized_Project_Can_Be_Saved_In_Event_Store() { var project = new Project(new Title("my project"), new ProjectDeadline(DateTime.UtcNow)); project.Reprioritize(ProjectPriority.Medium); var eventStoreRepository = new EventStoreRepository <Project>(EventBus, InMemoryEventStoreConnectionBuilder); eventStoreRepository.Save(project); Project projectFromEventStore = eventStoreRepository.GetById(project.Id); Assert.That(projectFromEventStore.Version, Is.EqualTo(2)); }
public void Install(IWindsorContainer container, IConfigurationStore store) { //Bus var bus = new InProcessBus(container); container.Register(Component.For <IBus>().Instance(bus)); var eventStore = GetInitializedEventStore(bus); var repository = new EventStoreRepository(eventStore, new AggregateFactory(), new ConflictDetector()); container.Register(Component.For <IStoreEvents>().Instance(eventStore)); container.Register(Component.For <IRepository>().Instance(repository)); }
public void ShouldThrowForEventStoreRepository() { // arrange var identityMap = new MemoryIdentityMap(); var repository = new EventStoreRepository(identityMap, new MemoryEventStore(), new MemorySnapshotStore()); var naturalKey = "key"; // act identityMap.GetOrAdd(typeof(Subject), typeof(string), naturalKey); Action action = () => repository.Load <Subject>(naturalKey); // assert action.ShouldThrow <AggregateRootNotFoundException>(); }
public static void RegisterEventStore() { //use a global singleton instead of IoC for this workshop var bus = new InProcessBus(); Globals.Bus = bus; var eventStore = GetInitializedEventStore(bus); var repository = new EventStoreRepository(eventStore, new AggregateFactory(), new ConflictDetector()); Globals.EventStore = eventStore; Globals.Repository = repository; Globals.ApplicationService = new HostDinnerApplicationService(Globals.Repository); }
private static async Task <Dispatcher> SetupDispatcher() { var eventStoreConnection = EventStoreConnection.Create( ConnectionSettings.Default, new IPEndPoint(IPAddress.Loopback, 1113)); await eventStoreConnection.ConnectAsync(); var repository = new EventStoreRepository(eventStoreConnection); var commandHandlerMap = new CommandHandlerMap(new Handlers(repository)); return(new Dispatcher(commandHandlerMap)); }
public static IDomainContext GetDomainContext() { KnownTypes.RegisterEvents(Assembly.GetExecutingAssembly()); var manifest = new SqlAggregateManifestRepository(EventSourcedDB.Main); var eventStore = new EventStoreRepository(EventSourcedDB.Main); var context = new TestDomainContext(EventSourcedDB.Main, manifest, eventStore); context.EventBus.Subscribe((x) => Console.WriteLine("domain bus event {0}", x)); // registrations context.RegisterBuilder<EventSourcedRoot>((c) => new TransactionReadModelBuilder(new SqlRepository<TransactionDataContract>(EventSourcedDB.Main))); return context; }
public static void RegisterEventStore() { //use a global singleton instead of IoC for this workshop var bus = new InProcessBus(); Globals.Bus = bus; var eventStore = GetInitializedEventStore(bus); var repository = new EventStoreRepository(eventStore, new AggregateFactory(), new ConflictDetector()); Globals.EventStore = eventStore; Globals.Repository = repository; Globals.ApplicationService = new HostDinnerApplicationService(Globals.Repository); var documentStore = new DocumentStore {Url = "http://localhost:8080/", DefaultDatabase = "NerdDinner"}; documentStore.Initialize(); Globals.RavenDocumentStore = documentStore; SetupDomainEventHandlers(bus); }
private void ConfigureHandlers() { var b = RabbitHutch.CreateBus("host=localhost"); var messageBusEndPoint = "barista"; var topicFilter = "Cashier.Common.Events"; var bus = new RabbitMqBus(b); ServiceLocator.Bus = bus; //Should get this from a config setting instead of hardcoding it. var eventStoreConnection = EventStoreConnection.Create(new IPEndPoint(IPAddress.Loopback, 12900)); eventStoreConnection.ConnectAsync().Wait(); var repository = new EventStoreRepository(eventStoreConnection, bus); ServiceLocator.OrderCommands = new BaristaOrderCommandHandlers(repository); var cashierEventHandler = new CashierOrderEventHandler(repository); ServiceLocator.CahierEventHandler = cashierEventHandler; var eventMappings = new EventHandlerDiscovery() .Scan(cashierEventHandler) .Handlers; b.Subscribe<PublishedMessage>(messageBusEndPoint, m => { Aggregate handler; var messageType = Type.GetType(m.MessageTypeName); var handlerFound = eventMappings.TryGetValue(messageType, out handler); if (handlerFound) { var @event = JsonConvert.DeserializeObject(m.SerialisedMessage, messageType); handler.AsDynamic().ApplyEvent(@event, ((Event)@event).Version); } }, q => q.WithTopic(topicFilter)); }
public void Setup() { this.eventstore = Wireup.Init() .UsingInMemoryPersistence() .UsingSynchronousDispatchScheduler() .DispatchTo(new DelegateMessageDispatcher(c => { c.Events.ForEach(dispatchedEvents.Add); c.Events.Select(m=>m.Body).ToList().ForEach(bus.Publish); })) .Build(); var aggregateRepository = new EventStoreRepository( eventstore , new AggregateFactory() ,new ConflictDetector()); var updateStorage = new InMemoryDbUpdateStorage(); this.readStorage = updateStorage; this.bus = ServiceBusFactory.New(sbc => { sbc.ReceiveFrom("loopback://localhost/test"); sbc.Subscribe(x => x.Consumer(() => new ManagerCommandHandler(aggregateRepository))); sbc.Subscribe(x => x.Consumer(() => new ManagerInfoDenormalizer(updateStorage))); }); var createManagerCommand = new CreateManager(managerId, "Max", "Cole"); bus.Publish(createManagerCommand); TaskManager taskManager = new TaskManager(TimeSpan.FromMilliseconds(500)); taskManager. When(() => this.readStorage.Items<ManagerInfo>().Any()). Then(()=>this.sync.Set()); this.sync.WaitOne(TimeSpan.FromSeconds(5)); }
private void ConfigureHandlers() { var b = RabbitHutch.CreateBus("host=localhost"); var bus = new RabbitMqBus(b); ServiceLocator.Bus = bus; var messageBusEndPoint = "cashier_service"; var topicFilter = "Admin.Common.Events"; var eventStorePort = 12900; var eventStoreConnection = EventStoreConnection.Create(new IPEndPoint(IPAddress.Loopback, eventStorePort)); eventStoreConnection.ConnectAsync().Wait(); var repository = new EventStoreRepository(eventStoreConnection, bus); ServiceLocator.OrderCommands = new OrderCommandHandlers(repository); ServiceLocator.ProductView = new ProductView(); var eventMappings = new EventHandlerDiscovery() .Scan(new AdminEventsHandler()) .Handlers; b.Subscribe<PublishedMessage>(messageBusEndPoint, m => { Aggregate handler; var messageType = Type.GetType(m.MessageTypeName); var handlerFound = eventMappings.TryGetValue(messageType, out handler); if (handlerFound) { var @event = JsonConvert.DeserializeObject(m.SerialisedMessage, messageType); handler.AsDynamic().ApplyEvent(@event, ((Event)@event).Version); } }, q => q.WithTopic(topicFilter)); }
public DiscussionCommandHandler(EventStoreRepository<Discussion> repository) { _repository = repository; }
public LinkCommandHandler(EventStoreRepository<Link> repository) { _repository = repository; }
public UserCommandHandler(EventStoreRepository<User> repository) { _repository = repository; }
public void Initialize() { _eventStoreRepository = new EventStoreRepository<Guid>(); }
public void Initialize() { InitializeViewCreators(); var repository = new EventStoreRepository( Wireup.Init(). UsingSqlPersistence("EntileEventStore").InitializeStorageEngine(). UsingJsonSerialization().UsingAsynchronousDispatchScheduler( new DelegateMessageDispatcher(c => { foreach (var e in c.Events) { _viewCreatorsDispatcher.Dispatch(e.Body as IMessage); } })). Build(), new AggregateFactory(), new ConflictDetector()); InitializeClientCommands(repository); }