public EventObservationStageDetails(ObservationStage stage)
{
Stage = stage;
ReceivedEvents = new List <TEvent>();
_actions = new List <Action <TModel, TEvent, IEventContext> >();
Actions = new ReadOnlyCollection <Action <TModel, TEvent, IEventContext> >(_actions);
}
public IEventObservable <TEvent, IEventContext, TModel> GetEventObservable <TEvent>(ObservationStage observationStage = ObservationStage.Normal)
{
if (_modelIid == null)
{
ThrowAsModelNotSet();
}
return(_underlying.GetEventObservable <TEvent, TModel>(_modelIid, observationStage));
}
private EventObservationStageDetails <TEvent> WireUpObservationStage <TEvent>(ObservationStage stage) where TEvent : BaseEvent
{
var details = new EventObservationStageDetails <TEvent>(stage);
details.ObservationDisposable = _router.GetEventObservable <TEvent, TModel>(_modelId, details.Stage)
.Observe(
(@event, context, model) =>
{
details.ReceivedEvents.Add(@event);
var shouldCancel = @event.ShouldCancel && stage == @event.CancelAtStage && @event.CancelAtEventProcesserId == _id;
if (shouldCancel)
{
context.Cancel();
}
var shouldCommit = @event.ShouldCommit && stage == @event.CommitAtStage && @event.CommitAtEventProcesserId == _id;
if (shouldCommit)
{
context.Commit();
}
var shouldRemove = @event.ShouldRemove && stage == @event.RemoveAtStage && @event.RemoveAtEventProcesserId == _id;
if (shouldRemove)
{
_router.RemoveModel(_modelId);
}
foreach (Action <TModel, TEvent, IEventContext> action in details.Actions)
{
action(model, @event, context);
}
},
() => details.StreamCompletedCount++);
return(details);
}
public IEventObservable <TEvent, IEventContext, TModel> GetEventObservable <TEvent, TModel>(object modelId, ObservationStage observationStage = ObservationStage.Normal)
{
_state.ThrowIfHalted();
IModelRouter <TModel> modelRouter = GetModelRouter <TModel>(modelId);
return(modelRouter.GetEventObservable <TEvent>(observationStage));
}
public IEventObservable <TEvent, IEventContext, TSubModel> GetEventObservable <TEvent>(ObservationStage observationStage = ObservationStage.Normal)
{
return(_underlying.GetEventObservable <TEvent, TModel>(_modelIid, observationStage).Select(_selector));
}
private void AssertLastReceivedEvent(int expectedEventReceivedCount, ObservationStage expectedObservationStage, BaseEvent sent)
{
_receivedEvents.Count.ShouldBe(expectedEventReceivedCount);
_receivedEvents[expectedEventReceivedCount - 1].Item2.ShouldBe(expectedObservationStage);
_receivedEvents[expectedEventReceivedCount - 1].Item1.ShouldBe(sent);
}
public ObserveEventAttribute(Type eventType, ObservationStage stage)
{
EventType = eventType;
Stage = stage;
}
/// <summary>
/// Returns an IEventObservable that will yield events of type TEvent when observed.
/// </summary>
/// <typeparam name="TEvent">Type type of event to observe</typeparam>
/// <param name="observationStage">The stage in the event processing workflow you wish to observe at</param>
/// <returns></returns>
public IEventObservable <TEvent, IEventContext, TModel> GetEventObservable <TEvent>(ObservationStage observationStage = ObservationStage.Normal)
{
return(EventObservable.Create <TEvent, IEventContext, TModel>(o =>
{
_state.ThrowIfHalted();
EventSubjects <TEvent> eventSubjects;
lock (_gate)
{
var eventType = typeof(TEvent);
if (!_eventSubjects.ContainsKey(eventType))
{
eventSubjects = new EventSubjects <TEvent>(_eventObservationRegistrar);
_eventSubjects[eventType] = eventSubjects;
}
else
{
eventSubjects = (EventSubjects <TEvent>)_eventSubjects[eventType];
}
}
EventSubject <TEvent, IEventContext, TModel> subject;
switch (observationStage)
{
case ObservationStage.Preview:
subject = eventSubjects.PreviewSubject;
break;
case ObservationStage.Normal:
subject = eventSubjects.NormalSubject;
break;
case ObservationStage.Committed:
subject = eventSubjects.CommittedSubject;
break;
default:
throw new ArgumentOutOfRangeException(string.Format("observationStage {0} not supported", observationStage));
}
return subject.Observe(o);
}));
}
