public AggregateModule(IAggregateSchema <TAggregate> schema,
ICommandDispatcher commandDispatcher,
ILogger logger,
IServiceProvider serviceProvider)
{
foreach (var i in schema.Commands)
{
//TODO: should cache ctor for performance
var binderType = typeof(PostBinder <>).MakeGenericType(typeof(TAggregate), i.Type);
var binder = Ctor <IBinder> .Create(binderType);
binder.BindCommand(schema, this, commandDispatcher, logger);
}
Get(schema.Category + "/{id:Guid}", async(request, response) =>
{
var stream = serviceProvider.GetService <IAggregateEventStream <TAggregate> >();
Guid id = request.RouteValues.As <Guid>("id");
var events = new List <IEvent>();
await foreach (var e in stream.Get(id))
{
events.Add(e);
}
await response.AsJson(events.ToArray());
});
}
private static AggregateEventStream <HotelAggregate> GetStream(IEventStoreFacade connection,
IAggregateSchema <HotelAggregate> schema)
{
AggregateEventStream <HotelAggregate> stream = new AggregateEventStream <HotelAggregate>(connection, new EventConverter(),
new EventDataFactory(), new EventMetadataFactory <HotelAggregate>(), schema, Logger.None);
return(stream);
}
public EventEntry(Type eventType, IAggregateSchema schema)
{
string text = $"{schema.Category.Humanize()} {eventType.Name.Humanize()}";
Description = new Statement(text);
EventType = eventType;
AggregateSchema = schema;
}
private Guid GetAggregateId(IAggregateSchema aggregateType)
{
if (!_defaultCatalogIdentifiers.TryGetValue(aggregateType.Category, out Guid aggregateId))
{
aggregateId = Guid.NewGuid();
_defaultCatalogIdentifiers.Add(aggregateType.Category, aggregateId);
}
return(aggregateId);
}
public AggregateEventStream(IEventStoreFacade connection,
IEventConverter eventConverter,
IEventDataFactory eventDataFactory,
IEventMetadataFactory <TAggregate> metadataFactory,
IAggregateSchema <TAggregate> aggregateSchema, Serilog.ILogger logger)
{
_connection = connection;
_eventConverter = eventConverter;
_eventDataFactory = eventDataFactory;
_metadataFactory = metadataFactory;
_aggregateSchema = aggregateSchema;
_logger = logger;
}
public void BindCommand(IAggregateSchema schema,
AggregateModule <TAggregate> module,
ICommandDispatcher commandDispatcher, ILogger logger)
{
var actionName = ServiceConventions.GetActionNameFromCommand(typeof(TCommand));
module.Post($"{schema.Category}/{actionName}/{{id:Guid}}",
async(request, response) =>
{
logger.Information("Handling {commandName}", typeof(TCommand).Name);
var stream = request.BodyReader.AsStream();
var streamReader = new StreamReader(stream);
var stringContent = await streamReader.ReadToEndAsync();
var cmd = JsonConvert.DeserializeObject <TCommand>(stringContent);
Guid id = request.RouteValues.As <Guid>("id");
await commandDispatcher.Dispatch(id, cmd);
await response.AsJson(cmd);
});
}
public AggregateSchema(IAggregateSchema schema)
{
_schema = schema;
}
