/// <summary>
/// Store a domain event
/// </summary>
/// <param name="batchId">Key used to store the domain event. It's not unique and therefore not PK either.</param>
/// <param name="domainEvent">The actual domain event</param>
public void Hold(Guid batchId, IDomainEvent domainEvent)
{
var batch = _session.Load<Batch>(batchId) ?? new Batch(batchId);
batch.Events.Add(domainEvent);
_session.Store(batch);
_session.SaveChanges();
}
protected void OnUpdated(IDomainEvent domainEvent = null)
{
if (domainEvent != null)
CaptureEvent(domainEvent);
this.LastUpdated = DateTimeOffset.Now;
}
public StoredEvent(string id, DateTime occuredOn, IDomainEvent domainEvent)
: base(id)
{
OccuredOn = occuredOn;
DomainEvent = domainEvent;
TypeName = domainEvent.GetType().Name;
}
public void Handle_Success_ShouldDispatchTheEventsReturnedFromTheCommandHandler(
[Frozen] Mock<ICommandHandler<ICommandThatPublishesDomainEvents>> commandHandler,
[Frozen] Mock<IDomainEventDispatcher> eventDispatcher,
ICommandThatPublishesDomainEvents command,
IDomainEvent domainEvent1,
IDomainEvent domainEvent2,
DomainEventDispatcherDecorator<ICommandThatPublishesDomainEvents> decorator)
{
// Arrange
var domainEvents = new List<IDomainEvent>
{
domainEvent1,
domainEvent2
};
commandHandler.Setup(d => d.Handle(command)).Returns(domainEvents);
// Act
var result = decorator.Handle(command).ToList();
// Verify
result[0].Should().Be(domainEvent1);
result[1].Should().Be(domainEvent2);
eventDispatcher.Verify(d => d.Dispatch(domainEvent1), Times.Once);
eventDispatcher.Verify(d => d.Dispatch(domainEvent2), Times.Once);
}
private void InvokeEventHandler(IDomainEvent e) {
var eventHandlerName = "On" + e.GetType().Name;
var methodInfo = GetType().GetMethod(eventHandlerName,
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
methodInfo.Invoke(this, new[] {e});
version++;
}
public IDomainEvent Record(IDomainEvent domainEvent)
{
var nhibEvent = new NHibEvent
{
EventDate = DateTime.Now,
Event = string.Empty
};
ISession session = _config.GetSession();
ITransaction transaction = session.BeginTransaction();
session.Save(nhibEvent);
domainEvent.Id = nhibEvent.Id;
nhibEvent.Event = XmlSerializationHelper.Serialize(domainEvent);
session.Save(nhibEvent);
var aggregateEvent = domainEvent as IAggregateEvent;
if (aggregateEvent != null)
{
var nhibAggregateEvent = new NHibAggregateEvent
{
EventId = nhibEvent.Id,
AggregateId = aggregateEvent.AggregateId
};
session.Save(nhibAggregateEvent);
}
transaction.Commit();
return domainEvent;
}
//[DebuggerStepThrough]
public void InvokeHandler(IDomainEvent e, EntityBase entity)
{
if (eventMutatesEntityState)
{
handler.Invoke(entity, new object[] {e});
}
}
public EventMessage(Guid aggregateId, int aggregateVersion, IDomainEvent @event)
{
this.AggregateId = aggregateId;
this.AggregateVersion = aggregateVersion;
this.Body = @event;
this.BodyType = @event.GetType().AssemblyQualifiedName;
}
/// <summary>
/// Initializes a new instance of the <see cref="DispatcherFailedEventArgs" /> class.
/// </summary>
/// <param name="exception">The thrown exception.</param>
/// <param name="domainEvent">The domain event in trouble.</param>
public DispatcherFailedEventArgs(Exception exception, IDomainEvent domainEvent)
{
if (exception == null) throw new ArgumentNullException("exception");
if (domainEvent == null) throw new ArgumentNullException("domainEvent");
Exception = exception;
DomainEvent = domainEvent;
}
public void Send(IDomainEvent e)
{
byte[] messageBody = StreamExtension.Serialize(e);
IBasicProperties basicProperties = model.CreateBasicProperties();
model.BasicPublish("exch", "key", basicProperties, messageBody);
}
protected void CaptureEvent(IDomainEvent domainEvent)
{
if (this.Events == null)
this.Events = new List<IDomainEvent>();
if (domainEvent != null)
this.Events.Add(domainEvent);
}
public void Dispatch(IDomainEvent e, string aggregateId)
{
var type = typeof(IEventHandler<>).MakeGenericType(e.GetType());
var handlers = this.container.ResolveAll(type);
foreach (var handler in handlers)
{
handler.AsDynamic().Handle(e, aggregateId);
}
}
public IEnumerable<Action<IDomainEvent>> GetEventHandlerActions(IDomainEvent domainEvent)
{
var handlers = _container.ResolveAll(typeof(IHandler<>).MakeGenericType(domainEvent.GetType()));
foreach (var handler in handlers)
{
var method = handler.GetType().GetMethod("Handle", new Type[] { domainEvent.GetType() });
yield return @event => method.Invoke(handler, new object[] { @event });
}
}
public void Dispatch(IDomainEvent message)
{
var handlers = _factory.GetEventHandlerActions(message);
foreach (var handler in handlers)
{
handler.Invoke(message);
}
}
public IEnumerable<string> GetReadModelIds(IDomainEvent domainEvent)
{
var messageAddedEvent = domainEvent as IDomainEvent<ThingyAggregate, ThingyId, ThingyMessageAddedEvent>;
if (messageAddedEvent == null)
{
yield break;
}
yield return messageAddedEvent.AggregateEvent.ThingyMessage.Id.Value;
}
public void UpdateEventDetails(IDomainEvent e, IAggregate aggregate, EntityBase source)
{
versionProperty.SetValue(e, aggregate.GetVersion());
aggregateIdentityProperty.SetValue(e, aggregate.Identity.GetId());
if (entityIdentityProperty != null)
{
entityIdentityProperty.SetValue(e, source.Identity.GetId());
}
}
// ----- Utils
private static OrderEvent ConvertToPersistentEvent(IDomainEvent domainEvent)
{
return new OrderEvent
{
AggregateId = domainEvent.AggregateId,
CreationDate = DateTime.Now,
Name = domainEvent.GetType().ToString(),
Content = JsonConvert.SerializeObject(domainEvent)
};
}
/// <summary>
/// Delegates the event and dispatches to all event handlers that subscribes to <see cref="IDomainEvent" />.
/// </summary>
/// <param name="domainEvent">Event to be dispatched.</param>
public void Dispatch(IDomainEvent domainEvent)
{
Guard.ArgumentIsNotNull(domainEvent, nameof(domainEvent));
var handlerType = typeof (IDomainEventHandler<>).MakeGenericType(domainEvent.GetType());
dynamic handlers = _container.GetAllInstances(handlerType);
foreach (var handler in handlers)
handler.Handle((dynamic) domainEvent);
}
public void Handle(IAggregateRoot root, IDomainEvent ev)
{
MethodInvoker invoker;
if (!_handlers.TryGetValue(ev.GetType(), out invoker))
{
throw new InvalidOperationException(string.Format("Apply method for event [{0}] wasn't resolved in [{1}]", ev.GetType().Name, root.GetType().Name));
}
invoker.Invoke(root, new object[] {ev});
}
/// <summary>
/// Store a domain event
/// </summary>
/// <param name="batchId">Key used to store the domain event. It's not unique and therefore not PK either.</param>
/// <param name="domainEvent">The actual domain event</param>
/// <exception cref="System.ArgumentException">Batchid is not specified.</exception>
public void Hold(Guid batchId, IDomainEvent domainEvent)
{
if (batchId == Guid.Empty)
throw new ArgumentException("You must specify a batchId", "batchId");
var domainEvents = _domainEvents.GetOrAdd(batchId, x => new LinkedList<IDomainEvent>());
// the actual list should only be used on the same thread
// hence thread safe.
domainEvents.Add(domainEvent);
}
public void Apply(IDomainEvent ev, bool isReplaying = false)
{
DomainSettings.Apply(this, ev);
Version++;
if (!isReplaying)
{
_uncommited.Add(ev);
}
}
public void Invoke(IDomainEvent evnt, MethodInfo handlerMethod, EventDispatchingContext context)
{
if (TypeUtil.IsAttributeDefinedInMethodOrDeclaringClass(handlerMethod, typeof(HandleAsyncAttribute)))
{
Task.Factory.StartNew(() => InvokeHandler(evnt, handlerMethod));
}
else
{
InvokeHandler(evnt, handlerMethod);
}
}
/// <summary>
/// Dispatch a new event to all listeners.
/// </summary>
/// <param name="e">Domain event</param>
/// <remarks>Exceptions are not handled and will there break the processing. It's up to the caller to process any exceptions.</remarks>
public void Dispatch(IDomainEvent e)
{
if (e == null) throw new ArgumentNullException("e");
var type = typeof (IAutoSubscriberOf<>).MakeGenericType(e.GetType());
var invokeMethod = type.GetMethod("Handle", new[] {e.GetType()});
var parameters = new object[] {e};
foreach (var handler in ServiceResolver.Current.ResolveAll(type))
{
invokeMethod.Invoke(handler, parameters);
}
}
private void AssertEquality(IDomainEvent[] expected, IDomainEvent[] actual)
{
for (int index = 0; index < expected.Length; index++)
{
string result = CompareObjects.FindDifferences(expected[index], actual[index]);
if (!string.IsNullOrWhiteSpace(result))
{
Assert.Fail("Expected event did not match the actual event.\n{0}", result);
}
}
}
private static IEnumerable<object> HandleEvent(IDomainEvent evnt, Type subscriberType)
{
IList<object> results = new List<object>();
var eventHandlers = EventSubscriberMappingStore.Current.GetEventHandlers(subscriberType).Where(eventHandler => IsEventHandler(eventHandler, evnt.GetType()));
foreach (var eventHandler in eventHandlers)
{
ExecuteEventHandler(eventHandler, GetSubscriber(subscriberType), evnt, ref results);
}
return results;
}
public void Publish(IDomainEvent evnt)
{
foreach (var subscriberType in DomainInitializer.Current.GetSubscriberTypesList(evnt.GetType()))
{
foreach (var result in HandleEvent(evnt, subscriberType))
{
if (result != null)
{
evnt.Results.Add(result);
}
}
}
}
public static void Publish(IDomainEvent evnt)
{
foreach (var subscriberType in EventSubscriberMappingStore.Current.GetSubscriberTypesList(evnt.GetType()))
{
foreach (var result in HandleEvent(evnt, subscriberType))
{
if (result != null)
{
evnt.Results.Add(result);
}
}
}
}
public static string Serialize(IDomainEvent ev)
{
var serializer = new XmlSerializer(ev.GetType());
var serializedEvent = new StringBuilder();
using (var writer = new StringWriter(serializedEvent))
{
serializer.Serialize(writer, ev);
}
return ev.GetType().AssemblyQualifiedName + "|" +
serializedEvent.ToString().Replace(Environment.NewLine, "");
}
internal static void Apply(IAggregateRoot root, IDomainEvent ev)
{
var rootType = root.GetType();
EventHandlerRegistry registry;
if (!_handlers.TryGetValue(rootType, out registry))
{
registry = new EventHandlerRegistry(ApplyMethodResolver.ResolveAll(rootType));
_handlers[rootType] = registry;
}
registry.Handle(root, ev);
//ResolveApplyMethodDelegate(root.GetType(), ev.GetType())(root, ev);
}
public void Publish(IDomainEvent theEvent)
{
if (theEvent == null)
{
throw new ArgumentNullException("The event should not be null");
}
var handlerType = typeof(IEventHandler<>).MakeGenericType(theEvent.GetType());
var handlers = this.container.GetAllInstances(handlerType);
foreach (dynamic handler in handlers)
{
handler.Handle((dynamic)theEvent);
}
}
public Task HandleAsync(IDomainEvent <ThingyAggregate, ThingyId, ThingyDomainErrorAfterFirstEvent> e, CancellationToken cancellationToken)
{
Console.WriteLine("Subscriber got ThingyDomainErrorAfterFirstEvent");
return(Task.FromResult(0));
}
public void Apply(IReadModelContext context, IDomainEvent <ThingyAggregate, ThingyId, ThingyPingEvent> domainEvent)
{
Id = domainEvent.AggregateEvent.PingId;
}
public void Apply(IDomainEvent evt)
{
IsDeleted = true;
}
public Task SaveEventAsync <TAggregate>(IDomainEvent @event, int?expectedVersion = null) where TAggregate : IAggregateRoot
{
throw new NotImplementedException(Consts.StoreRequiredMessage);
}
public void Apply(IReadModelContext context, IDomainEvent <Domain.Booking.Booking, BookingId, PassengerNameUpdatedEvent> domainEvent)
{
var passenger = Passengers.Single(p => p.PassengerKey == domainEvent.AggregateEvent.PassengerKey);
passenger.Name = domainEvent.AggregateEvent.Name;
}
public void SetDomainEvent(IDomainEvent domainEvent)
{
_domainEvent = domainEvent;
}
protected virtual Task OnEventReceived(IDomainEvent <TKey> e)
{
var handler = EventReceived;
return(handler?.Invoke(this, e));
}
public EventLogItem ApplyMapping(IDomainEvent @event)
{
var mapping = (IEventLogMappingDefinition)Activator.CreateInstance(mappings[@event.GetType()]);
return(mapping.Apply(@event));
}
public void AddDomainEvent(IDomainEvent eventItem)
{
_domainEvents = _domainEvents ?? new List <IDomainEvent>();
_domainEvents.Add(eventItem);
}
public void RemoveDomainEvent(IDomainEvent eventItem)
{
_domainEvents?.Remove(eventItem);
}
private void PublishAndApply(IDomainEvent evt)
{
_publisher.Publish(evt);
_decision.Apply(evt);
}
public Result LogEvent(IDomainEvent @event)
{
var log = DomainEventLog.CreateLog(@event);
return(_logRepository.AddLog(log).Tap(() => _dbContext.SaveChanges()));
}
protected void Raise(IDomainEvent @event)
{
_changes.Add(@event);
}
public Task HandleAsync(IDomainEvent <MovieAggregate, MovieId, MovieCreatedEvent> @event, CancellationToken cancellationToken)
{
Console.WriteLine($"Movie created {@event.AggregateEvent.Movie.Title}");
return(Task.CompletedTask);
}
/// <summary>
/// Add domain event.
/// </summary>
/// <param name="domainEvent"></param>
protected void AddDomainEvent(IDomainEvent domainEvent)
{
_domainEvents ??= new List <IDomainEvent>();
this._domainEvents.Add(domainEvent);
}
public bool HasMapping(IDomainEvent message)
{
return(mappings.ContainsKey(message.GetType()));
}
/// <summary>
/// Adds the given <paramref name="@event" /> to the internal storage
/// </summary>
/// <param name="event">The event</param>
public void Add(IDomainEvent @event)
{
_datastore.Store(@event);
}
public void Apply(IReadModelContext context, IDomainEvent <Aggregates.Car, CarId, CarDeleted> @event)
{
context.MarkForDeletion();
}
protected void RemoveDomainEvent(IDomainEvent @event) => _domainEvents.Remove(@event);
public void Apply(IReadModelContext context, IDomainEvent <ThingyAggregate, ThingyId, ThingyDomainErrorAfterFirstEvent> domainEvent)
{
Id = domainEvent.AggregateIdentity.Value;
DomainErrorAfterFirstReceived = true;
}
protected void AddDomainEvent(IDomainEvent @event) => _domainEvents.Add(@event);
/// <summary>
/// Adds the event to the new events collection and calls the related apply method.
/// </summary>
/// <param name="event">The event.</param>
protected void AddAndApplyEvent(IDomainEvent @event)
{
_events.Add(@event);
this.AsDynamic().Apply(@event);
}
protected virtual void AddDomainEvent(IDomainEvent newEvent)
{
_domainEvents.Add(newEvent);
}
public void Apply(IReadModelContext context, IDomainEvent <ThingyAggregate, ThingyId, ThingyPingEvent> domainEvent)
{
Id = domainEvent.AggregateIdentity.Value;
PingsReceived++;
}
public void Apply(IReadModelContext context, IDomainEvent <Domain.Booking.Booking, BookingId, PassengerAddedEvent> domainEvent)
{
Passengers.Add(domainEvent.AggregateEvent.Passenger.ToReadModel());
}
protected abstract void Apply(IDomainEvent <TKey> @event);
public void Apply(IReadModelContext context, IDomainEvent <Aggregates.Car, CarId, CarEdited> @event)
{
this.Name = @event.AggregateEvent.Title;
this.BatteryCapacity = @event.AggregateEvent.BatteryCapacity.Value;
}
/// <summary> /// Adiciona um evento de domínio à entidade. /// </summary> /// <param name="eventItem"></param> public void AddDomainEvent(IDomainEvent eventItem) => domainEvents.Add(eventItem);
private void RouteToEntity(IDomainEventHandler <int> handler, IDomainEvent <int> evt) => InEntity.processEvent(handler, evt, evt.EventVersion + 1);
/// <summary>
/// TBD
/// </summary>
/// <param name="e">TBD</param>
/// <exception cref="ArgumentException">TBD</exception>
/// <returns>TBD</returns>
public State Updated(IDomainEvent e)
{
if (e is ShardRegionRegistered)
{
var message = e as ShardRegionRegistered;
if (Regions.ContainsKey(message.Region))
{
throw new ArgumentException($"Region {message.Region} is already registered", nameof(e));
}
return(Copy(regions: Regions.SetItem(message.Region, ImmutableList <ShardId> .Empty)));
}
else if (e is ShardRegionProxyRegistered)
{
var message = e as ShardRegionProxyRegistered;
if (RegionProxies.Contains(message.RegionProxy))
{
throw new ArgumentException($"Region proxy {message.RegionProxy} is already registered", nameof(e));
}
return(Copy(regionProxies: RegionProxies.Add(message.RegionProxy)));
}
else if (e is ShardRegionTerminated)
{
IImmutableList <ShardId> shardRegions;
var message = e as ShardRegionTerminated;
if (!Regions.TryGetValue(message.Region, out shardRegions))
{
throw new ArgumentException($"Region {message.Region} not registered", nameof(e));
}
return(Copy(
regions: Regions.Remove(message.Region),
shards: Shards.RemoveRange(shardRegions),
unallocatedShards: shardRegions.Aggregate(UnallocatedShards, (set, shard) => set.Add(shard))));
}
else if (e is ShardRegionProxyTerminated)
{
var message = e as ShardRegionProxyTerminated;
if (!RegionProxies.Contains(message.RegionProxy))
{
throw new ArgumentException($"Region proxy {message.RegionProxy} not registered", nameof(e));
}
return(Copy(regionProxies: RegionProxies.Remove(message.RegionProxy)));
}
else if (e is ShardHomeAllocated)
{
IImmutableList <ShardId> shardRegions;
var message = e as ShardHomeAllocated;
if (!Regions.TryGetValue(message.Region, out shardRegions))
{
throw new ArgumentException($"Region {message.Region} not registered", nameof(e));
}
if (Shards.ContainsKey(message.Shard))
{
throw new ArgumentException($"Shard {message.Shard} is already allocated", nameof(e));
}
return(Copy(
shards: Shards.SetItem(message.Shard, message.Region),
regions: Regions.SetItem(message.Region, shardRegions.Add(message.Shard)),
unallocatedShards: UnallocatedShards.Remove(message.Shard)));
}
else if (e is ShardHomeDeallocated)
{
IActorRef region;
IImmutableList <ShardId> shardRegions;
var message = e as ShardHomeDeallocated;
if (!Shards.TryGetValue(message.Shard, out region))
{
throw new ArgumentException($"Shard {message.Shard} not allocated", nameof(e));
}
if (!Regions.TryGetValue(region, out shardRegions))
{
throw new ArgumentException($"Region {region} for shard {message.Shard} not registered", nameof(e));
}
return(Copy(
shards: Shards.Remove(message.Shard),
regions: Regions.SetItem(region, shardRegions.Where(s => s != message.Shard).ToImmutableList()),
unallocatedShards: UnallocatedShards.Add(message.Shard)));
}
else
{
return(this);
}
}
