public async Task Save(TAggregateRoot aggregateRoot)
{
// Check for concurrency issues
await ConcurrencyCheck(aggregateRoot);
// Persist Events
foreach (var uncommittedEvent in aggregateRoot.UncommittedEvents)
{
TEventSet @event = (TEventSet)Activator.CreateInstance(typeof(TEventSet), uncommittedEvent);
await Client.CreateDocumentAsync(_databaseCollectionUri, @event);
}
// Check if snapshot is required
bool snapshotRequired = CanProcessSnapshots &&
aggregateRoot.UncommittedEvents.Any(
eventWrapper => eventWrapper.Sequence % SnapshotRepository.SnapshotInterval == 0
);
if (snapshotRequired)
{
await SnapshotRepository.SaveSnapshot(aggregateRoot);
}
// Publish events if possible
if (CanPublishEvents)
{
foreach (var uncommittedEvent in aggregateRoot.UncommittedEvents)
{
await DomainEventBus.Publish(uncommittedEvent.Event);
}
}
// Mark aggregate root as committed
aggregateRoot.MarkAsCommitted();
}
/// <summary>
/// Remove
/// </summary>
public virtual void Remove()
{
repository.Remove((T)this);
DomainEventBus.Publish(new DefaultAggregationRemoveDomainEvent <T>()
{
Object = this as T
});
}
public async Task Execute(ProductId id, ProductName name)
{
var product = Product.Create(id, name);
await productRepository.Save(product).ConfigureAwait(false);
eventBus.Publish(product.GetDomainEvents());
}
/// <summary>
/// Remove
/// </summary>
public virtual async Task RemoveAsync()
{
await repository.RemoveAsync((T)this).ConfigureAwait(false);
DomainEventBus.Publish(new DefaultAggregationRemoveDomainEvent <T>()
{
Object = this as T
});
}
/// <summary>
/// Save
/// </summary>
public virtual Result <T> Save()
{
var saveData = repository.Save(this as T);
if (saveData == null)
{
return(Result <T> .FailedResult("Data saved failed"));
}
DomainEventBus.Publish(new DefaultAggregationSaveDomainEvent <T>()
{
Object = saveData
});
return(Result <T> .SuccessResult("Data saved successfully", "", saveData));
}
/// <summary>
/// Remove
/// </summary>
public virtual Result Remove()
{
if (IdentityValueIsNone())
{
throw new EZNEWException("The object does not have an identity value set and cannot perform a remove");
}
T removeData = this as T;
repository.Remove(removeData);
DomainEventBus.Publish(new DefaultAggregationRemoveDomainEvent <T>()
{
Object = removeData
});
return(Result.SuccessResult("Data removed successfully"));
}
public void WhenHandlerRegisteredForBaseType_ThenHandlesOnRaise()
{
var args = new FooArgs {
Id = 5
};
var handler = new Mock <DomainEventHandler <int, BaseArgs> > {
CallBase = true
};
var bus = new DomainEventBus <int>(new[] { handler.Object });
bus.Publish(new TestAggregate(), args);
handler.Verify(x => x.Handle(5, It.IsAny <BaseArgs>()));
}
public void WhenAsyncHandlerRegisteredForSpecificType_ThenCanUseDefaultAsynRunner()
{
var args = new FooArgs {
Id = 5
};
var handler = new Mock <DomainEventHandler <int, FooArgs> > {
CallBase = true
};
handler.Setup(x => x.IsAsync).Returns(true);
var bus = new DomainEventBus <int>(new[] { handler.Object });
bus.Publish(new TestAggregate(), args);
handler.Verify(x => x.Handle(5, args), Times.Never());
}
public void WhenAsyncHandlerRegisteredForSpecificType_ThenInvokesAsyncRunner()
{
var args = new FooArgs {
Id = 5
};
var handler = new Mock <DomainEventHandler <int, FooArgs> > {
CallBase = true
};
handler.Setup(x => x.IsAsync).Returns(true);
var asyncCalled = false;
Action <Action> asyncRunner = action => asyncCalled = true;
var bus = new DomainEventBus <int>(new[] { handler.Object }, asyncRunner);
bus.Publish(new TestAggregate(), args);
handler.Verify(x => x.Handle(5, args), Times.Never());
Assert.True(asyncCalled);
}
public virtual void Save(TAggregateRoot aggregateRoot)
{
var set = Context.Set <TEventSet>();
//Check for concurrency issues
ConcurrencyCheck <TAggregateRoot, TEventSet> .Process(aggregateRoot, set);
//Persist Events
foreach (var uncommittedEvent in aggregateRoot.UncommittedEvents)
{
var @event = CreateDomainEventRecord(uncommittedEvent);
PersistedEvents.Add(@event);
}
//Check if snapshot is required
var snapshotRequired = CanProcessSnapshots &&
aggregateRoot.UncommittedEvents.Any(
e => e.Sequence % SnapshotRepository.SnapshotInterval == 0);
if (snapshotRequired)
{
SnapshotRepository.SaveSnapshot(aggregateRoot);
}
Context.SaveChanges();
//Publish events if possible
if (CanPublishEvents)
{
foreach (var uncommittedEvent in aggregateRoot.UncommittedEvents)
{
DomainEventBus.Publish(uncommittedEvent.Event);
}
}
//Mark aggregate root as committed
aggregateRoot.MarkAsCommitted();
}
public void WhenPublishNullAggregate_ThenThrows()
{
var bus = new DomainEventBus <int>(Enumerable.Empty <DomainEventHandler>());
Assert.Throws <ArgumentNullException>(() => bus.Publish((AggregateRoot <int>)null, new FooArgs()));
}
public void WhenPublishNullEvent_ThenThrows()
{
var bus = new DomainEventBus <int>(Enumerable.Empty <DomainEventHandler>());
Assert.Throws <ArgumentNullException>(() => bus.Publish(new TestAggregate(), default(FooArgs)));
}
