public ProcessStateActor(IAggregateCommandsHandler <ProcessStateAggregate <TState> > handler,
ISnapshotsPersistencePolicy snapshotsPersistencePolicy,
IConstructAggregates aggregateConstructor,
IConstructSnapshots snapshotsConstructor,
IActorRef customHandlersActor) : base(handler,
snapshotsPersistencePolicy,
aggregateConstructor,
snapshotsConstructor,
customHandlersActor)
{
}
public AggregateActor(IAggregateCommandsHandler <TAggregate> handler,
ISnapshotsPersistencePolicy snapshotsPersistencePolicy,
IConstructAggregates aggregateConstructor,
IConstructSnapshots snapshotsConstructor,
IActorRef customHandlersActor) : base(aggregateConstructor, snapshotsConstructor, snapshotsPersistencePolicy)
{
_aggregateCommandsHandler = handler;
_publisher = Context.System.GetTransport();
_customHandlersActor = customHandlersActor;
_domainEventProcessEntry = new ProcessEntry(Self.Path.Name, AggregateActorConstants.PublishingEvent, AggregateActorConstants.CommandExecutionCreatedAnEvent);
_domainEventProcessFailEntry = new ProcessEntry(Self.Path.Name, AggregateActorConstants.CommandExecutionFinished, AggregateActorConstants.CommandRaisedAnError);
_commandCompletedProcessEntry = new ProcessEntry(Self.Path.Name, AggregateActorConstants.CommandExecutionFinished, AggregateActorConstants.ExecutedCommand);
Behavior.Become(AwaitingCommandBehavior, nameof(AwaitingCommandBehavior));
}
public AggregateActor(IAggregateCommandsHandler<TAggregate> handler,
TypedMessageActor<ScheduleCommand> schedulerActorRef,
TypedMessageActor<Unschedule> unscheduleActorRef,
IPublisher publisher,
ISnapshotsPersistencePolicy snapshotsPersistencePolicy,
IConstructAggregates aggregateConstructor) : base(
aggregateConstructor,
snapshotsPersistencePolicy,
publisher)
{
_schedulerActorRef = schedulerActorRef;
_unscheduleActorRef = unscheduleActorRef;
_handler = handler;
//async aggregate method execution finished, aggregate already raised events
//need process it in usual way
Command<IMessageMetadataEnvelop<AsyncEventsReceived>>(d =>
{
var m = d.Message;
Monitor.IncrementMessagesReceived();
if (m.Exception != null)
{
ProcessFault(m.Command, m.Exception, d.Metadata);
return;
}
(State as Aggregate).FinishAsyncExecution(m.InvocationId);
ProcessAggregateEvents(m.Command, d.Metadata);
});
Command<IMessageMetadataEnvelop<ICommand>>(m =>
{
var cmd = m.Message;
Monitor.IncrementMessagesReceived();
_log.Trace("{Aggregate} received a {@command}", State.Id, cmd);
try
{
State = _handler.Execute((TAggregate)State, cmd);
}
catch (Exception ex)
{
ProcessFault(cmd, ex, m.Metadata);
return;
}
ProcessAggregateEvents(cmd, m.Metadata);
});
}
public static AggregateScenario <TAggregate> New <TAggregate>(IAggregateCommandsHandler <TAggregate> handler) where TAggregate : Aggregate
{
return(new AggregateScenario <TAggregate>(CreateAggregate <TAggregate>(), handler));
}
public static DefaultAggregateDependencyFactory <TAggregate> New <TAggregate>(IAggregateCommandsHandler <TAggregate> handler, IMessageRouteMap mapProducer = null) where TAggregate : IAggregate
{
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
var map = mapProducer ?? MessageRouteMap.New(handler);
return(new DefaultAggregateDependencyFactory <TAggregate>(() => handler, () => map));
}
