public override DbTransaction TransactionStarted(DbConnection connection, TransactionEndEventData eventData, DbTransaction result)
{
//Debug.WriteLine(Environment.StackTrace);
_logger.LogInformation("TransactionStarted: {0}", eventData.TransactionId);
return(base.TransactionStarted(connection, eventData, result));
}
public DbTransaction TransactionStarted(DbConnection connection, TransactionEndEventData eventData,
DbTransaction result)
{
TrackEvent(nameof(TransactionStarted), connection, eventData.ConnectionId);
return(result);
}
public override void TransactionCommitted(DbTransaction transaction, TransactionEndEventData eventData)
{
Debug.WriteLine(Environment.StackTrace);
_logger.LogInformation("TransactionCommitted: {0}", eventData.TransactionId);
base.TransactionCommitted(transaction, eventData);
}
public ValueTask <DbTransaction> TransactionStartedAsync(DbConnection connection,
TransactionEndEventData eventData,
DbTransaction result,
CancellationToken cancellationToken = new CancellationToken())
{
TrackEvent(nameof(TransactionStartedAsync), connection, eventData.ConnectionId);
return(ValueTask.FromResult(result));
}
public void TransactionCommitted(
DbTransaction transaction,
TransactionEndEventData eventData)
{
for (var i = 0; i < _interceptors.Length; i++)
{
_interceptors[i].TransactionCommitted(transaction, eventData);
}
}
public void TransactionRolledBack(
DbTransaction transaction,
TransactionEndEventData eventData)
{
for (var i = 0; i < _interceptors.Length; i++)
{
_interceptors[i].TransactionRolledBack(transaction, eventData);
}
}
public override DbTransaction TransactionStarted(
DbConnection connection,
TransactionEndEventData eventData,
DbTransaction result)
{
result = base.TransactionStarted(connection, eventData, result);
return(new WrappedDbTransaction(result));
}
public async Task TransactionRolledBackAsync(
DbTransaction transaction,
TransactionEndEventData eventData,
CancellationToken cancellationToken = default)
{
for (var i = 0; i < _interceptors.Length; i++)
{
await _interceptors[i].TransactionRolledBackAsync(transaction, eventData, cancellationToken);
}
}
public override async Task <DbTransaction> TransactionStartedAsync(
DbConnection connection,
TransactionEndEventData eventData,
DbTransaction result,
CancellationToken cancellationToken = default)
{
result = await base.TransactionStartedAsync(connection, eventData, result, cancellationToken);
return(new WrappedDbTransaction(result));
}
public async Task TransactionCommittedAsync(
DbTransaction transaction,
TransactionEndEventData eventData,
CancellationToken cancellationToken = default)
{
for (var i = 0; i < _interceptors.Length; i++)
{
await _interceptors[i].TransactionCommittedAsync(transaction, eventData, cancellationToken)
.ConfigureAwait(false);
}
}
public DbTransaction TransactionStarted(
DbConnection connection,
TransactionEndEventData eventData,
DbTransaction result)
{
for (var i = 0; i < _interceptors.Length; i++)
{
result = _interceptors[i].TransactionStarted(connection, eventData, result);
}
return(result);
}
public async Task <DbTransaction> TransactionStartedAsync(
DbConnection connection,
TransactionEndEventData eventData,
DbTransaction result,
CancellationToken cancellationToken = default)
{
for (var i = 0; i < _interceptors.Length; i++)
{
result = await _interceptors[i].TransactionStartedAsync(connection, eventData, result, cancellationToken);
}
return(result);
}
public override async void TransactionCommitted(
DbTransaction transaction,
TransactionEndEventData eventData)
{
try
{
await PublishEvents(eventData);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error in EventTransactionInterceptor");
}
finally
{
base.TransactionCommitted(transaction, eventData);
}
}
public override async Task TransactionCommittedAsync(
DbTransaction transaction,
TransactionEndEventData eventData,
CancellationToken cancellationToken = default)
{
try
{
await PublishEvents(eventData);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error in EventTransactionInterceptor");
}
finally
{
await base.TransactionCommittedAsync(transaction, eventData, cancellationToken);
}
}
public override async Task <DbTransaction> TransactionStartedAsync(DbConnection connection, TransactionEndEventData eventData, DbTransaction result, CancellationToken cancellationToken = new CancellationToken())
{
return(await base.TransactionStartedAsync(connection, eventData, result, cancellationToken));
}
public override async Task TransactionRolledBackAsync(DbTransaction transaction, TransactionEndEventData eventData, CancellationToken cancellationToken = new CancellationToken())
{
await base.TransactionRolledBackAsync(transaction, eventData, cancellationToken);
}
private async Task PublishEvents(TransactionEndEventData eventData)
{
var entries = GetEntries(eventData.Context as SteamfitterContext);
using (var scope = _serviceProvider.CreateScope())
{
var events = new List <INotification>();
var mediator = scope.ServiceProvider.GetRequiredService <IMediator>();
foreach (var entry in entries)
{
var entityType = entry.Entity.GetType();
Type eventType = null;
string[] modifiedProperties = null;
switch (entry.State)
{
case EntityState.Added:
eventType = typeof(EntityCreated <>).MakeGenericType(entityType);
// Make sure properties generated by the db are set
var generatedProps = entry.Properties
.Where(x => x.Metadata.ValueGenerated == Microsoft.EntityFrameworkCore.Metadata.ValueGenerated.OnAdd)
.ToList();
foreach (var prop in generatedProps)
{
entityType.GetProperty(prop.Metadata.Name).SetValue(entry.Entity, prop.CurrentValue);
}
break;
case EntityState.Modified:
eventType = typeof(EntityUpdated <>).MakeGenericType(entityType);
modifiedProperties = entry.Properties
.Where(x => x.IsModified)
.Select(x => x.Metadata.Name)
.ToArray();
break;
case EntityState.Deleted:
eventType = typeof(EntityDeleted <>).MakeGenericType(entityType);
break;
}
if (eventType != null)
{
INotification evt;
if (modifiedProperties != null)
{
evt = Activator.CreateInstance(eventType, new[] { entry.Entity, modifiedProperties }) as INotification;
}
else
{
evt = Activator.CreateInstance(eventType, new[] { entry.Entity }) as INotification;
}
if (evt != null)
{
events.Add(evt);
}
}
}
foreach (var evt in events)
{
await mediator.Publish(evt);
}
}
}
public override Task TransactionCommittedAsync(DbTransaction transaction, TransactionEndEventData eventData, CancellationToken cancellationToken = default)
{
return(Task.CompletedTask);
}
public void TransactionCommitted(DbTransaction transaction, TransactionEndEventData eventData)
{
TrackEvent(nameof(TransactionCommitted), transaction.Connection, eventData.ConnectionId);
}
/// <summary>
/// Called immediately after EF calls <see cref="DbConnection.BeginTransaction(IsolationLevel)" />.
/// </summary>
/// <remarks>
/// This method is still called if an interceptor suppressed creation in <see cref="IDbTransactionInterceptor.TransactionStarting" />.
/// In this case, <paramref name="result" /> is the result returned by <see cref="IDbTransactionInterceptor.TransactionStarting" />.
/// </remarks>
/// <param name="connection">The connection.</param>
/// <param name="eventData">Contextual information about connection and transaction.</param>
/// <param name="result">
/// The result of the call to <see cref="DbConnection.BeginTransaction(IsolationLevel)" />.
/// This value is typically used as the return value for the implementation of this method.
/// </param>
/// <returns>
/// The result that EF will use.
/// A normal implementation of this method for any interceptor that is not attempting to change the result
/// is to return the <paramref name="result" /> value passed in.
/// </returns>
public virtual DbTransaction TransactionStarted(
DbConnection connection,
TransactionEndEventData eventData,
DbTransaction result)
=> result;
public override void TransactionRolledBack(DbTransaction transaction, TransactionEndEventData eventData)
{
base.TransactionRolledBack(transaction, eventData);
}
public override void TransactionCommitted(DbTransaction transaction, TransactionEndEventData eventData)
{
base.TransactionCommitted(transaction, eventData);
}
public void TransactionRolledBack(DbTransaction transaction, TransactionEndEventData eventData)
{
TrackEvent(nameof(TransactionRolledBack), transaction.Connection, eventData.ConnectionId);
}
public Task TransactionRolledBackAsync(DbTransaction transaction, TransactionEndEventData eventData,
CancellationToken cancellationToken = new CancellationToken())
{
TrackEvent(nameof(TransactionRolledBackAsync), transaction.Connection, eventData.ConnectionId);
return(Task.CompletedTask);
}
