private void Main()
{
var aggregateRoot = new AggregateRootRepository(new MSSqlEventStore("connectionString", new MicroJsonTypeSerializer()), new MSSqlAggregateRootSnapshotStore("connectionString", new MicroJsonTypeSerializer()));
var myAggregate = aggregateRoot.GetByID<MyAggregate>("ID");
if (myAggregate.HasChanged)
aggregateRoot.Save(myAggregate);
}
public async Task Should_Publish_Aggregate_Events_When_Saving_Through_Repository()
{
const int expectedChanges = 2;
var changes = new List <Change>();
var aggregateId = Guid.NewGuid();
var cancellationToken = default(CancellationToken);
var storage = Substitute.For <IStorage>();
var repository = new AggregateRootRepository <FakeAggregate>(storage, null);
var aggregate = new FakeAggregate(aggregateId, nameof(FakeAggregate));
aggregate.Subscribe(changes.Add);
aggregate.PerformAction();
Assert.Empty(changes);
await repository.SaveAsync(aggregate, cancellationToken);
Assert.Equal(expectedChanges, changes.Count);
Assert.Collection(
changes,
change =>
{
Assert.NotNull(change.Event);
Assert.IsType <FakeCreateEvent>(change.Event);
},
change =>
{
Assert.NotNull(change.Event);
Assert.IsType <FakeDummyActionEvent>(change.Event);
});
}
public void SaveAndLoadWithEntityRepository()
{
Converts.Repository
.AddJsonKey()
.AddJsonEnumSearchHandler()
.AddJsonPrimitivesSearchHandler()
.AddJsonObjectSearchHandler();
ICompositeTypeProvider compositeTypeProvider = new ReflectionCompositeTypeProvider(new ReflectionCompositeDelegateFactory());
IFactory <ICompositeStorage> storageFactory = new GetterFactory <ICompositeStorage>(() => new JsonCompositeStorage());
EventSourcingContext context = new EventSourcingContext(@"Data Source=.\sqlexpress; Initial Catalog=EventStore;Integrated Security=SSPI");
EntityEventStore eventStore = new EntityEventStore(context);
PersistentEventDispatcher eventDispatcher = new PersistentEventDispatcher(eventStore);
AggregateRootRepository <Order> repository = new AggregateRootRepository <Order>(
eventStore,
new CompositeEventFormatter(compositeTypeProvider, storageFactory),
new ReflectionAggregateRootFactory <Order>(),
eventDispatcher,
new NoSnapshotProvider(),
new EmptySnapshotStore()
);
PersistentCommandDispatcher commandDispatcher = new PersistentCommandDispatcher(
new SerialCommandDistributor(),
new EntityCommandStore(context),
new CompositeCommandFormatter(compositeTypeProvider, storageFactory)
);
CreateOrderHandler createHandler = new CreateOrderHandler(repository);
AddOrderItemHandler addItemHandler = new AddOrderItemHandler(repository);
commandDispatcher.Handlers
.Add <CreateOrder>(createHandler)
.Add <AddOrderItem>(addItemHandler);
CreateOrder create = new CreateOrder();
commandDispatcher.HandleAsync(create);
eventDispatcher.Handlers.Await <OrderPlaced>().Wait();
IEnumerable <EventModel> serializedEvents = eventStore.Get(create.OrderKey).ToList();
Assert.AreEqual(1, serializedEvents.Count());
AddOrderItem addItem = new AddOrderItem(create.OrderKey, GuidKey.Create(Guid.NewGuid(), "Product"), 5);
commandDispatcher.HandleAsync(Envelope.Create(addItem).AddDelay(TimeSpan.FromMinutes(1)));
Task <OrderTotalRecalculated> task = eventDispatcher.Handlers.Await <OrderTotalRecalculated>();
task.Wait();
Console.WriteLine(task.Result);
serializedEvents = eventStore.Get(create.OrderKey).ToList();
Assert.AreEqual(4, serializedEvents.Count());
}
public async Task Should_Load_Aggregate_Correctly_Through_Repository()
{
FakeAggregate AggregateFactory() => (FakeAggregate)Activator.CreateInstance(typeof(FakeAggregate), true);
var aggregateId = Guid.NewGuid();
var cancellationToken = default(CancellationToken);
var expectedName = $"{nameof(FakeAggregate)}Renamed";
const int expectedVersion = 1;
var storedEvents = new IEvent[]
{
new FakeCreateEvent(aggregateId, nameof(FakeAggregate))
{
Version = 0
},
new FakeRenameEvent(nameof(FakeAggregate), expectedName)
{
Version = 1
}
};
var storage = Substitute.For <IStorage>();
storage
.LoadEventsAsync(aggregateId, cancellationToken)
.Returns(storedEvents);
var repository = new AggregateRootRepository <FakeAggregate>(storage, AggregateFactory);
var aggregate = await repository.LoadAsync(aggregateId, cancellationToken);
Assert.Equal(expectedVersion, (aggregate as IAggregateRoot).Version);
Assert.Equal(aggregateId, (aggregate as IAggregateRoot).Id);
Assert.Equal(expectedName, aggregate.Name);
}
public static void Constructor()
{
var aggregateRoot = new AggregateRootRepository(new MongoDBEventStore("server=127.0.0.1;database=test"), new MongoDBAggregateRootSnapshotStore("server=127.0.0.1;database=test"));
var myAggregate = aggregateRoot.GetByID<MyAggregate>("ID");
if (myAggregate.HasChanged)
aggregateRoot.Save(myAggregate);
}
public static void Constructor()
{
var aggregateRoot = new AggregateRootRepository(new MongoDBEventStore("server=127.0.0.1;database=test"), new MongoDBAggregateRootSnapshotStore("server=127.0.0.1;database=test"));
var myAggregate = aggregateRoot.GetByID <MyAggregate>("ID");
if (myAggregate.HasChanged)
{
aggregateRoot.Save(myAggregate);
}
}
private void Main()
{
var aggregateRoot = new AggregateRootRepository(new MSSqlEventStore("connectionString", new JsonTypeSerializer()), new MSSqlAggregateRootSnapshotStore("connectionString", new JsonTypeSerializer()));
var myAggregate = aggregateRoot.GetByID <MyAggregate>("ID");
if (myAggregate.HasChanged)
{
aggregateRoot.Save(myAggregate);
}
}
private void Domain()
{
Converts.Repository
.AddJsonEnumSearchHandler()
.AddJsonPrimitivesSearchHandler()
.AddJsonObjectSearchHandler()
.AddJsonKey()
.AddJsonTimeSpan()
.Add(new ColorConverter());
EventStore = new EntityEventStore(Factory.Default <EventSourcingContext>());
eventDispatcher = new PersistentEventDispatcher(new EmptyEventStore());
eventDispatcher.DispatcherExceptionHandlers.Add(this);
eventDispatcher.EventExceptionHandlers.Add(this);
IFactory <ICompositeStorage> compositeStorageFactory = Factory.Default <JsonCompositeStorage>();
ICompositeTypeProvider typeProvider = new ReflectionCompositeTypeProvider(
new ReflectionCompositeDelegateFactory(),
BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public
);
EventFormatter = new CompositeEventFormatter(typeProvider, compositeStorageFactory);
OutcomeRepository = new AggregateRootRepository <Outcome>(
EventStore,
EventFormatter,
new ReflectionAggregateRootFactory <Outcome>(),
eventDispatcher,
new NoSnapshotProvider(),
new EmptySnapshotStore()
);
CategoryRepository = new AggregateRootRepository <Category>(
EventStore,
EventFormatter,
new ReflectionAggregateRootFactory <Category>(),
eventDispatcher,
new NoSnapshotProvider(),
new EmptySnapshotStore()
);
PriceFactory = new PriceFactory("CZK");
DomainFacade = new DefaultDomainFacade(
OutcomeRepository,
CategoryRepository,
PriceFactory
);
}
public async Task Should_Save_On_Storage_When_Saving_Aggregate()
{
IAggregateRoot AggregateFactory() => Substitute.For <IAggregateRoot>();
var cancellationToken = default(CancellationToken);
var storage = Substitute.For <IStorage>();
storage
.SaveChangesAsync(Arg.Any <IEnumerable <UncommittedChange> >(), cancellationToken)
.Returns(Task.CompletedTask);
var aggregate = Substitute.For <IAggregateRoot>();
var repository = new AggregateRootRepository <IAggregateRoot>(storage, AggregateFactory);
await repository.SaveAsync(aggregate, cancellationToken);
await storage
.Received()
.SaveChangesAsync(Arg.Any <IEnumerable <UncommittedChange> >(), cancellationToken);
}
public async Task Should_Load_From_Storage_When_Loading_Aggregate()
{
IAggregateRoot AggregateFactory() => Substitute.For <IAggregateRoot>();
var aggregateId = Guid.NewGuid();
var cancellationToken = default(CancellationToken);
var storage = Substitute.For <IStorage>();
var storedEvents = new IEvent[0];
storage
.LoadEventsAsync(aggregateId, cancellationToken)
.Returns(storedEvents);
IAggregateRootRepository <IAggregateRoot> repository = new AggregateRootRepository <IAggregateRoot>(storage, AggregateFactory);
await repository.LoadAsync(aggregateId, cancellationToken);
await storage
.Received()
.LoadEventsAsync(aggregateId, cancellationToken);
}
private void Domain()
{
Converts.Repository
.AddStringTo <int>(Int32.TryParse)
.AddStringTo <bool>(Boolean.TryParse)
.AddEnumSearchHandler(false)
.AddJsonEnumSearchHandler()
.AddJsonPrimitivesSearchHandler()
.AddJsonObjectSearchHandler()
.AddJsonKey()
.AddJsonTimeSpan()
.Add(new ColorConverter())
.AddToStringSearchHandler();
EventStore = new EntityEventStore(ServiceProvider.EventSourcingContextFactory);
eventDispatcher = new PersistentEventDispatcher(new EmptyEventStore());
eventDispatcher.DispatcherExceptionHandlers.Add(this);
eventDispatcher.EventExceptionHandlers.Add(this);
IFactory <ICompositeStorage> compositeStorageFactory = Factory.Default <JsonCompositeStorage>();
typeProvider = new ReflectionCompositeTypeProvider(
new ReflectionCompositeDelegateFactory(),
BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public
);
CommandFormatter = new CompositeCommandFormatter(typeProvider, compositeStorageFactory);
EventFormatter = new CompositeEventFormatter(typeProvider, compositeStorageFactory, new List <ICompositeFormatterExtender>()
{
new UserKeyEventExtender()
});
commandDispatcher = new PersistentCommandDispatcher(new SerialCommandDistributor(), new EmptyCommandStore(), CommandFormatter);
OutcomeRepository = new AggregateRootRepository <Outcome>(
EventStore,
EventFormatter,
new ReflectionAggregateRootFactory <Outcome>(),
eventDispatcher,
new NoSnapshotProvider(),
new EmptySnapshotStore()
);
CategoryRepository = new AggregateRootRepository <Category>(
EventStore,
EventFormatter,
new ReflectionAggregateRootFactory <Category>(),
eventDispatcher,
new NoSnapshotProvider(),
new EmptySnapshotStore()
);
CurrencyListRepository = new AggregateRootRepository <CurrencyList>(
EventStore,
EventFormatter,
new ReflectionAggregateRootFactory <CurrencyList>(),
eventDispatcher,
new NoSnapshotProvider(),
new EmptySnapshotStore()
);
Money.BootstrapTask bootstrapTask = new Money.BootstrapTask(
commandDispatcher.Handlers,
Factory.Instance(OutcomeRepository),
Factory.Instance(CategoryRepository),
Factory.Instance(CurrencyListRepository)
);
bootstrapTask.Initialize();
}
private void Domain(IServiceProvider provider)
{
Converts.Repository
.AddStringTo <int>(Int32.TryParse)
.AddStringTo <bool>(Boolean.TryParse)
.AddEnumSearchHandler(false)
.AddJsonEnumSearchHandler()
.AddJsonPrimitivesSearchHandler()
.AddJsonObjectSearchHandler()
.AddJsonKey()
.AddJsonTimeSpan()
.Add(new ColorConverter())
.AddToStringSearchHandler();
var eventSourcingContextFactory = provider.GetRequiredService <IFactory <EventSourcingContext> >();
eventStore = new EntityEventStore(eventSourcingContextFactory);
eventDispatcher = new PersistentEventDispatcher(new EmptyEventStore());
eventDispatcher.DispatcherExceptionHandlers.Add(exceptionHandlerBuilder);
eventDispatcher.EventExceptionHandlers.Add(exceptionHandlerBuilder);
IFactory <ICompositeStorage> compositeStorageFactory = Factory.Default <JsonCompositeStorage>();
typeProvider = new ReflectionCompositeTypeProvider(
new ReflectionCompositeDelegateFactory(),
BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public
);
commandFormatter = new CompositeCommandFormatter(typeProvider, compositeStorageFactory);
eventFormatter = new CompositeEventFormatter(typeProvider, compositeStorageFactory, new List <ICompositeFormatterExtender>()
{
new UserKeyEventExtender()
});
queryFormatter = new CompositeListFormatter(typeProvider, compositeStorageFactory, logFactory);
exceptionFormatter = new CompositeExceptionFormatter(typeProvider, compositeStorageFactory);
commandDispatcher = new PersistentCommandDispatcher(new SerialCommandDistributor(), new EmptyCommandStore(), commandFormatter);
commandDispatcher.DispatcherExceptionHandlers.Add(exceptionHandlerBuilder);
commandDispatcher.CommandExceptionHandlers.Add(exceptionHandlerBuilder);
queryDispatcher = new DefaultQueryDispatcher();
var snapshotProvider = new NoSnapshotProvider();
var snapshotStore = new EmptySnapshotStore();
var outcomeRepository = new AggregateRootRepository <Outcome>(
eventStore,
eventFormatter,
new ReflectionAggregateRootFactory <Outcome>(),
eventDispatcher,
snapshotProvider,
snapshotStore
);
var expenseTemplateRepository = new AggregateRootRepository <ExpenseTemplate>(
eventStore,
eventFormatter,
new ReflectionAggregateRootFactory <ExpenseTemplate>(),
eventDispatcher,
snapshotProvider,
snapshotStore
);
var incomeRepository = new AggregateRootRepository <Income>(
eventStore,
eventFormatter,
new ReflectionAggregateRootFactory <Income>(),
eventDispatcher,
snapshotProvider,
snapshotStore
);
var categoryRepository = new AggregateRootRepository <Category>(
eventStore,
eventFormatter,
new ReflectionAggregateRootFactory <Category>(),
eventDispatcher,
snapshotProvider,
snapshotStore
);
var currencyListRepository = new AggregateRootRepository <CurrencyList>(
eventStore,
eventFormatter,
new ReflectionAggregateRootFactory <CurrencyList>(),
eventDispatcher,
snapshotProvider,
snapshotStore
);
Money.BootstrapTask bootstrapTask = new Money.BootstrapTask(
commandDispatcher.Handlers,
Factory.Instance(outcomeRepository),
Factory.Instance(expenseTemplateRepository),
Factory.Instance(incomeRepository),
Factory.Instance(categoryRepository),
Factory.Instance(currencyListRepository)
);
bootstrapTask.Initialize();
ServiceProvider serviceProvider = services.BuildServiceProvider();
UserHandler userHandler = new UserHandler(
serviceProvider.GetRequiredService <UserManager <User> >(),
serviceProvider.GetRequiredService <IFactory <AccountContext> >(),
eventDispatcher,
allowedUserPropertyKeys
);
commandDispatcher.Handlers.AddAll(userHandler);
queryDispatcher.AddAll(userHandler);
}
