/// <summary> /// Handles the event. /// </summary> /// <param name = "evnt">The event to handle. /// <remarks> /// This value should not be <c>null</c>. /// </remarks> /// </param> /// <returns> /// <c>true</c> when the event was handled; otherwise, <c>false</c>. /// <remarks> /// <c>false</c> does not mean that the handling failed, but that the /// handler was not interested in handling this event. /// </remarks> /// </returns> public bool HandleEvent(DomainEvent evnt) { Contract.Requires<ArgumentNullException>(evnt != null, "The evnt cannot be null."); var handled = false; if (ShouldHandleThisEvent(evnt)) { _handler(evnt); handled = true; } return handled; }
public void It_should_call_the_converter_for_each_event() { var store = MockRepository.GenerateMock<IEventStore>(); var bus = MockRepository.GenerateMock<IEventBus>(); var converter = MockRepository.GenerateMock<IEventConverter<DomainEvent, DomainEvent>>(); Func<DomainEvent, DomainEvent> returnFirstParam = (x) => x; converter.Stub(c => c.Convert(null)).IgnoreArguments().Do(returnFirstParam); var aggId = Guid.NewGuid(); var eventsInTheStore = new DomainEvent[] { new FooEvent(Guid.NewGuid(), aggId, 1, DateTime.UtcNow), new BarEvent(Guid.NewGuid(), aggId, 2, DateTime.UtcNow) }; store.Expect(s => s.GetAllEvents(aggId)).Return(eventsInTheStore); var repository = new DomainRepository(store, bus, null, converter); repository.GetById<MyAggregateRoot>(aggId); converter.AssertWasCalled(c => c.Convert(null),options => options.IgnoreArguments().Repeat.Twice()); }
private void ApplyEvent(DomainEvent evnt, Boolean historical) { if(historical) { if(evnt.EventSequence != InitialVersion+1) { var message = String.Format("Cannot apply event with sequence {0}. Since the initial version of the " + "aggregate root is {1}. Only an event with sequence number {2} can be applied.", evnt.EventSequence, InitialVersion, InitialVersion + 1); throw new InvalidOperationException(message); } } else { if (evnt.AggregateRootId != Guid.Empty) { var message = String.Format("The {0} event cannot be applied to aggregate root {1} with id {2} " + "since it was already owned by event aggregate root with id {3}.", evnt.GetType().FullName, this.GetType().FullName, Id, evnt.AggregateRootId); throw new InvalidOperationException(message); } evnt.AggregateRootId = this.Id; evnt.EventSequence = Version + 1; } HandleEvent(evnt); if (!historical) { _uncommittedEvent.Enqueue(evnt); RegisterCurrentInstanceAsDirty(); } }
protected virtual void HandleEvent(DomainEvent evnt) { Contract.Requires<ArgumentNullException>(evnt != null, "The evnt cannot be null."); Boolean handled = false; foreach (var handler in _eventHandlers) { handled |= handler.HandleEvent(evnt); } if (!handled) throw new EventNotHandledException(evnt); }
protected void ApplyEvent(DomainEvent evnt) { ApplyEvent(evnt, false); }
/// <summary> /// Determine whether the event should be handled or not. /// </summary> /// <param name = "evnt">The event.</param> /// <returns><c>true</c> when this event should be handled; otherwise, <c>false</c>.</returns> private bool ShouldHandleThisEvent(DomainEvent evnt) { Contract.Assume(evnt != null, "The evnt should not be null."); var shouldHandle = false; var evntType = evnt.GetType(); // This is true when the eventTypeThreshold is // true if event type and the threshold type represent the same type, or if the theshold type is in the inheritance hierarchy // of the event type, or if the threshold type is an interface that event type implements. if (_eventTypeThreshold.IsAssignableFrom(evntType)) { if (_exact) { // Only handle the event when there is an exact match. shouldHandle = (_eventTypeThreshold == evntType); } else { // Handle the event, since it the threshold is assignable from the event type. shouldHandle = true; } } return shouldHandle; }
public new void ApplyEvent(DomainEvent e) { base.ApplyEvent(e); }
public bool HandleEvent(DomainEvent evnt) { Contract.Requires<ArgumentNullException>(evnt != null, "The evnt cannot be null."); return default(bool); }
private void CatchAllHandler(DomainEvent e) { }
public void OnDomainEvent(DomainEvent e1, DomainEvent e2) { }
public static void OnDomainEvent(DomainEvent e) { }