(GH-603) Added a new repository interception context object

johelvisguzman · johelvisguzman · commit 005913c1255a · 2020-03-26T00:43:45.000-04:00
diff --git a/src/DotNetToolkit.Repository/Configuration/Interceptors/IRepositoryInterceptor.cs b/src/DotNetToolkit.Repository/Configuration/Interceptors/IRepositoryInterceptor.cs
@@ -12,48 +12,48 @@ public interface IRepositoryInterceptor
         /// An activity method which is executed when adding an entity to the repository.
         /// </summary>
         /// <typeparam name="TEntity">The type of the entity.</typeparam>
-        /// <param name="entity">The entity.</param>
-        void AddExecuting<TEntity>(TEntity entity);
+        /// <param name="interceptionContext">The interception context which includes information for the current operation.</param>
+        void AddExecuting<TEntity>(RepositoryInterceptionContext<TEntity> interceptionContext) where TEntity : class;
 
         /// <summary>
         /// An activity method which is executed when deleting an entity from the repository.
         /// </summary>
         /// <typeparam name="TEntity">The type of the entity.</typeparam>
-        /// <param name="entity">The entity.</param>
-        void DeleteExecuting<TEntity>(TEntity entity);
+        /// <param name="interceptionContext">The interception context which includes information for the current operation.</param>
+        void DeleteExecuting<TEntity>(RepositoryInterceptionContext<TEntity> interceptionContext) where TEntity : class;
 
         /// <summary>
         /// An activity method which is executed when updating an entity in the repository.
         /// </summary>
         /// <typeparam name="TEntity">The type of the entity.</typeparam>
-        /// <param name="entity">The entity.</param>
-        void UpdateExecuting<TEntity>(TEntity entity);
+        /// <param name="interceptionContext">The interception context which includes information for the current operation.</param>
+        void UpdateExecuting<TEntity>(RepositoryInterceptionContext<TEntity> interceptionContext) where TEntity : class;
 
         /// <summary>
         /// Asynchronously an activity method which is executed when adding an entity to the repository.
         /// </summary>
         /// <typeparam name="TEntity">The type of the entity.</typeparam>
-        /// <param name="entity">The entity.</param>
+        /// <param name="interceptionContext">The interception context which includes information for the current operation.</param>
         /// <param name="cancellationToken">A <see cref="System.Threading.CancellationToken" /> to observe while waiting for the task to complete.</param>
         /// <returns>The <see cref="System.Threading.Tasks.Task" /> that represents the asynchronous operation.</returns>
-        Task AddExecutingAsync<TEntity>(TEntity entity, CancellationToken cancellationToken = new CancellationToken());
+        Task AddExecutingAsync<TEntity>(RepositoryInterceptionContext<TEntity> interceptionContext, CancellationToken cancellationToken = new CancellationToken()) where TEntity : class;
 
         /// <summary>
         /// Asynchronously an activity method which is executed when deleting an entity from the repository.
         /// </summary>
         /// <typeparam name="TEntity">The type of the entity.</typeparam>
-        /// <param name="entity">The entity.</param>
+        /// <param name="interceptionContext">The interception context which includes information for the current operation.</param>
         /// <param name="cancellationToken">A <see cref="System.Threading.CancellationToken" /> to observe while waiting for the task to complete.</param>
         /// <returns>The <see cref="System.Threading.Tasks.Task" /> that represents the asynchronous operation.</returns>
-        Task DeleteExecutingAsync<TEntity>(TEntity entity, CancellationToken cancellationToken = new CancellationToken());
+        Task DeleteExecutingAsync<TEntity>(RepositoryInterceptionContext<TEntity> interceptionContext, CancellationToken cancellationToken = new CancellationToken()) where TEntity : class;
 
         /// <summary>
         /// Asynchronously an activity method which is executed when updating an entity in the repository.
         /// </summary>
         /// <typeparam name="TEntity">The type of the entity.</typeparam>
-        /// <param name="entity">The entity.</param>
+        /// <param name="interceptionContext">The interception context which includes information for the current operation.</param>
         /// <param name="cancellationToken">A <see cref="System.Threading.CancellationToken" /> to observe while waiting for the task to complete.</param>
         /// <returns>The <see cref="System.Threading.Tasks.Task" /> that represents the asynchronous operation.</returns>
-        Task UpdateExecutingAsync<TEntity>(TEntity entity, CancellationToken cancellationToken = new CancellationToken());
+        Task UpdateExecutingAsync<TEntity>(RepositoryInterceptionContext<TEntity> interceptionContext, CancellationToken cancellationToken = new CancellationToken()) where TEntity : class;
     }
 }
diff --git a/src/DotNetToolkit.Repository/Configuration/Interceptors/RepositoryInterceptionContext.cs b/src/DotNetToolkit.Repository/Configuration/Interceptors/RepositoryInterceptionContext.cs
@@ -0,0 +1,33 @@
+﻿namespace DotNetToolkit.Repository.Configuration.Interceptors
+{
+    using JetBrains.Annotations;
+    using Utility;
+
+    /// <summary>
+    /// Represents contextual information associated with calls into <see cref="IRepositoryInterceptor" />.
+    /// </summary>
+    /// <typeparam name="TEntity">The type of the entity associated to the current operation.</typeparam>
+    public class RepositoryInterceptionContext<TEntity> where TEntity : class
+    {
+        /// <summary>
+        /// Gets the entity associated with the current operation.
+        /// </summary>
+        public TEntity Entity { get; }
+
+        /// <summary>
+        /// Gets the context.
+        /// </summary>
+        public IRepositoryContext Context { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RepositoryInterceptionContext{TEntity}"/> class.
+        /// </summary>
+        /// <param name="entity">The entity.</param>
+        /// <param name="context">The context.</param>
+        public RepositoryInterceptionContext([NotNull] TEntity entity, [NotNull] IRepositoryContext context)
+        {
+            Entity = Guard.NotNull(entity, nameof(entity));
+            Context = Guard.NotNull(context, nameof(context));
+        }
+    }
+}
diff --git a/src/DotNetToolkit.Repository/Configuration/Interceptors/RepositoryInterceptorBase.cs b/src/DotNetToolkit.Repository/Configuration/Interceptors/RepositoryInterceptorBase.cs
@@ -13,48 +13,48 @@ public abstract class RepositoryInterceptorBase : IRepositoryInterceptor
         /// An activity method which is executed when adding an entity to the repository.
         /// </summary>
         /// <typeparam name="TEntity">The type of the entity.</typeparam>
-        /// <param name="entity">The entity.</param>
-        public virtual void AddExecuting<TEntity>(TEntity entity) { }
+        /// <param name="interceptionContext">The interception context which includes information for the current operation.</param>
+        public virtual void AddExecuting<TEntity>(RepositoryInterceptionContext<TEntity> interceptionContext) where TEntity : class {}
 
         /// <summary>
         /// An activity method which is executed when deleting an entity from the repository.
         /// </summary>
         /// <typeparam name="TEntity">The type of the entity.</typeparam>
-        /// <param name="entity">The entity.</param>
-        public virtual void DeleteExecuting<TEntity>(TEntity entity) { }
+        /// <param name="interceptionContext">The interception context which includes information for the current operation.</param>
+        public virtual void DeleteExecuting<TEntity>(RepositoryInterceptionContext<TEntity> interceptionContext) where TEntity : class {}
 
         /// <summary>
         /// An activity method which is executed when updating an entity in the repository.
         /// </summary>
         /// <typeparam name="TEntity">The type of the entity.</typeparam>
-        /// <param name="entity">The entity.</param>
-        public virtual void UpdateExecuting<TEntity>(TEntity entity) { }
+        /// <param name="interceptionContext">The interception context which includes information for the current operation.</param>
+        public virtual void UpdateExecuting<TEntity>(RepositoryInterceptionContext<TEntity> interceptionContext) where TEntity : class {}
 
         /// <summary>
         /// Asynchronously an activity method which is executed when adding an entity to the repository.
         /// </summary>
         /// <typeparam name="TEntity">The type of the entity.</typeparam>
-        /// <param name="entity">The entity.</param>
+        /// <param name="interceptionContext">The interception context which includes information for the current operation.</param>
         /// <param name="cancellationToken">A <see cref="System.Threading.CancellationToken" /> to observe while waiting for the task to complete.</param>
         /// <returns>The <see cref="System.Threading.Tasks.Task" /> that represents the asynchronous operation.</returns>
-        public virtual Task AddExecutingAsync<TEntity>(TEntity entity, CancellationToken cancellationToken = new CancellationToken()) => Task.FromResult(0);
+        public virtual Task AddExecutingAsync<TEntity>(RepositoryInterceptionContext<TEntity> interceptionContext, CancellationToken cancellationToken = new CancellationToken()) where TEntity : class => Task.FromResult(0);
 
         /// <summary>
         /// Asynchronously an activity method which is executed when deleting an entity from the repository.
         /// </summary>
         /// <typeparam name="TEntity">The type of the entity.</typeparam>
-        /// <param name="entity">The entity.</param>
+        /// <param name="interceptionContext">The interception context which includes information for the current operation.</param>
         /// <param name="cancellationToken">A <see cref="System.Threading.CancellationToken" /> to observe while waiting for the task to complete.</param>
         /// <returns>The <see cref="System.Threading.Tasks.Task" /> that represents the asynchronous operation.</returns>
-        public virtual Task DeleteExecutingAsync<TEntity>(TEntity entity, CancellationToken cancellationToken = new CancellationToken()) => Task.FromResult(0);
+        public virtual Task DeleteExecutingAsync<TEntity>(RepositoryInterceptionContext<TEntity> interceptionContext, CancellationToken cancellationToken = new CancellationToken()) where TEntity : class => Task.FromResult(0);
 
         /// <summary>
         /// Asynchronously an activity method which is executed when updating an entity in the repository.
         /// </summary>
         /// <typeparam name="TEntity">The type of the entity.</typeparam>
-        /// <param name="entity">The entity.</param>
+        /// <param name="interceptionContext">The interception context which includes information for the current operation.</param>
         /// <param name="cancellationToken">A <see cref="System.Threading.CancellationToken" /> to observe while waiting for the task to complete.</param>
         /// <returns>The <see cref="System.Threading.Tasks.Task" /> that represents the asynchronous operation.</returns>
-        public virtual Task UpdateExecutingAsync<TEntity>(TEntity entity, CancellationToken cancellationToken = new CancellationToken()) => Task.FromResult(0);
+        public virtual Task UpdateExecutingAsync<TEntity>(RepositoryInterceptionContext<TEntity> interceptionContext, CancellationToken cancellationToken = new CancellationToken()) where TEntity : class => Task.FromResult(0);
     }
 }
diff --git a/src/DotNetToolkit.Repository/RepositoryBase.cs b/src/DotNetToolkit.Repository/RepositoryBase.cs
@@ -1430,10 +1430,11 @@ public void Add([NotNull] TEntity entity)
 
             InterceptError(() => Guard.NotNull(entity, nameof(entity)));
 
-            Intercept(x => x.AddExecuting(entity));
-
             UseContext(context =>
             {
+                Intercept(x => x.AddExecuting(
+                    new RepositoryInterceptionContext<TEntity>(entity, context)));
+
                 context.Add(entity);
                 context.SaveChanges();
             });
@@ -1457,7 +1458,8 @@ public void Add([NotNull] IEnumerable<TEntity> entities)
             {
                 foreach (var entity in entities)
                 {
-                    Intercept(x => x.AddExecuting(entity));
+                    Intercept(x => x.AddExecuting(
+                        new RepositoryInterceptionContext<TEntity>(entity, context)));
 
                     context.Add(entity);
                 }
@@ -1480,10 +1482,11 @@ public void Update([NotNull] TEntity entity)
 
             InterceptError(() => Guard.NotNull(entity, nameof(entity)));
 
-            Intercept(x => x.UpdateExecuting(entity));
-
             UseContext(context =>
             {
+                Intercept(x => x.UpdateExecuting(
+                    new RepositoryInterceptionContext<TEntity>(entity, context)));
+
                 context.Update(entity);
                 context.SaveChanges();
             });
@@ -1507,7 +1510,8 @@ public void Update([NotNull] IEnumerable<TEntity> entities)
             {
                 foreach (var entity in entities)
                 {
-                    Intercept(x => x.UpdateExecuting(entity));
+                    Intercept(x => x.UpdateExecuting(
+                        new RepositoryInterceptionContext<TEntity>(entity, context)));
 
                     context.Update(entity);
                 }
@@ -1530,10 +1534,11 @@ public void Delete([NotNull] TEntity entity)
 
             InterceptError(() => Guard.NotNull(entity, nameof(entity)));
 
-            Intercept(x => x.DeleteExecuting(entity));
-
             UseContext(context =>
             {
+                Intercept(x => x.DeleteExecuting(
+                    new RepositoryInterceptionContext<TEntity>(entity, context)));
+
                 context.Remove(entity);
                 context.SaveChanges();
             });
@@ -1591,7 +1596,8 @@ public void Delete([NotNull] IEnumerable<TEntity> entities)
             {
                 foreach (var entity in entities)
                 {
-                    Intercept(x => x.DeleteExecuting(entity));
+                    Intercept(x => x.DeleteExecuting(
+                        new RepositoryInterceptionContext<TEntity>(entity, context)));
 
                     context.Remove(entity);
                 }
@@ -2175,10 +2181,12 @@ Task<int> Getter() =>
                 cancellationToken.ThrowIfCancellationRequested();
             });
 
-            await InterceptAsync(x => x.AddExecutingAsync(entity, cancellationToken));
-
             await UseContextAsync(async context =>
             {
+                await InterceptAsync(x => x.AddExecutingAsync(
+                    new RepositoryInterceptionContext<TEntity>(entity, context),
+                    cancellationToken));
+
                 context.Add(entity);
                 await context.SaveChangesAsync(cancellationToken);
             });
@@ -2209,7 +2217,9 @@ await UseContextAsync(async context =>
             {
                 foreach (var entity in entities)
                 {
-                    await InterceptAsync(x => x.AddExecutingAsync(entity, cancellationToken));
+                    await InterceptAsync(x => x.AddExecutingAsync(
+                        new RepositoryInterceptionContext<TEntity>(entity, context),
+                        cancellationToken));
 
                     context.Add(entity);
                 }
@@ -2239,10 +2249,12 @@ await UseContextAsync(async context =>
                 cancellationToken.ThrowIfCancellationRequested();
             });
 
-            await InterceptAsync(x => x.UpdateExecutingAsync(entity, cancellationToken));
-
             await UseContextAsync(async context =>
             {
+                await InterceptAsync(x => x.UpdateExecutingAsync(
+                    new RepositoryInterceptionContext<TEntity>(entity, context),
+                    cancellationToken));
+
                 context.Update(entity);
                 await context.SaveChangesAsync(cancellationToken);
             });
@@ -2273,7 +2285,9 @@ await UseContextAsync(async context =>
             {
                 foreach (var entity in entities)
                 {
-                    await InterceptAsync(x => x.UpdateExecutingAsync(entity, cancellationToken));
+                    await InterceptAsync(x => x.UpdateExecutingAsync(
+                        new RepositoryInterceptionContext<TEntity>(entity, context),
+                        cancellationToken));
 
                     context.Update(entity);
                 }
@@ -2303,10 +2317,12 @@ await UseContextAsync(async context =>
                 cancellationToken.ThrowIfCancellationRequested();
             });
 
-            await InterceptAsync(x => x.DeleteExecutingAsync(entity, cancellationToken));
-
             await UseContextAsync(async context =>
             {
+                await InterceptAsync(x => x.DeleteExecutingAsync(
+                    new RepositoryInterceptionContext<TEntity>(entity, context), 
+                    cancellationToken));
+
                 context.Remove(entity);
                 await context.SaveChangesAsync(cancellationToken);
             });
@@ -2377,7 +2393,9 @@ await UseContextAsync(async context =>
             {
                 foreach (var entity in entities)
                 {
-                    await InterceptAsync(x => x.DeleteExecutingAsync(entity, cancellationToken));
+                    await InterceptAsync(x => x.DeleteExecutingAsync(
+                        new RepositoryInterceptionContext<TEntity>(entity, context),
+                        cancellationToken));
 
                     context.Remove(entity);
                 }
diff --git a/test/DotNetToolkit.Repository.Integration.Test/Data/TestRepositoryTimeStampInterceptor.cs b/test/DotNetToolkit.Repository.Integration.Test/Data/TestRepositoryTimeStampInterceptor.cs
@@ -23,9 +23,9 @@ public TestRepositoryTimeStampInterceptor(string loggedInUser)
             _user = loggedInUser;
         }
 
-        public override void AddExecuting<TEntity>(TEntity entity)
+        public override void AddExecuting<TEntity>(RepositoryInterceptionContext<TEntity> interceptionContext)
         {
-            if (entity is IHaveTimeStamp haveStamp)
+            if (interceptionContext.Entity is IHaveTimeStamp haveStamp)
             {
                 var currentTime = DateTime.UtcNow;
 
@@ -36,9 +36,9 @@ public override void AddExecuting<TEntity>(TEntity entity)
             }
         }
 
-        public override void UpdateExecuting<TEntity>(TEntity entity)
+        public override void UpdateExecuting<TEntity>(RepositoryInterceptionContext<TEntity> interceptionContext)
         {
-            if (entity is IHaveTimeStamp haveStamp)
+            if (interceptionContext.Entity is IHaveTimeStamp haveStamp)
             {
                 var currentTime = DateTime.UtcNow;
 
@@ -47,9 +47,9 @@ public override void UpdateExecuting<TEntity>(TEntity entity)
             }
         }
 
-        public override Task AddExecutingAsync<TEntity>(TEntity entity, CancellationToken cancellationToken = new CancellationToken())
+        public override Task AddExecutingAsync<TEntity>(RepositoryInterceptionContext<TEntity> interceptionContext, CancellationToken cancellationToken = new CancellationToken())
         {
-            if (entity is IHaveTimeStamp haveStamp)
+            if (interceptionContext.Entity is IHaveTimeStamp haveStamp)
             {
                 var currentTime = DateTime.UtcNow;
 
@@ -62,9 +62,9 @@ public override void UpdateExecuting<TEntity>(TEntity entity)
             return Task.FromResult(0);
         }
 
-        public override Task UpdateExecutingAsync<TEntity>(TEntity entity, CancellationToken cancellationToken = new CancellationToken())
+        public override Task UpdateExecutingAsync<TEntity>(RepositoryInterceptionContext<TEntity> interceptionContext, CancellationToken cancellationToken = new CancellationToken())
         {
-            if (entity is IHaveTimeStamp haveStamp)
+            if (interceptionContext.Entity is IHaveTimeStamp haveStamp)
             {
                 var currentTime = DateTime.UtcNow;
 
diff --git a/test/DotNetToolkit.Repository.Integration.Test/Tests/Interceptor/RepositoryInterceptorTests.cs b/test/DotNetToolkit.Repository.Integration.Test/Tests/Interceptor/RepositoryInterceptorTests.cs

Original file line number	Diff line number	Diff line change
`@@ -1430,10 +1430,11 @@ public void Add([NotNull] TEntity entity)`
`1430`	`1430`
`1431`	`1431`	`InterceptError(() => Guard.NotNull(entity, nameof(entity)));`
`1432`	`1432`
`1433`		`- Intercept(x => x.AddExecuting(entity));`
`1434`		`-`
`1435`	`1433`	`UseContext(context =>`
`1436`	`1434`	`{`
	`1435`	`+ Intercept(x => x.AddExecuting(`
	`1436`	`+ new RepositoryInterceptionContext<TEntity>(entity, context)));`
	`1437`	`+`
`1437`	`1438`	`context.Add(entity);`
`1438`	`1439`	`context.SaveChanges();`
`1439`	`1440`	`});`
`@@ -1457,7 +1458,8 @@ public void Add([NotNull] IEnumerable<TEntity> entities)`
`1457`	`1458`	`{`
`1458`	`1459`	`foreach (var entity in entities)`
`1459`	`1460`	`{`
`1460`		`- Intercept(x => x.AddExecuting(entity));`
	`1461`	`+ Intercept(x => x.AddExecuting(`
	`1462`	`+ new RepositoryInterceptionContext<TEntity>(entity, context)));`
`1461`	`1463`
`1462`	`1464`	`context.Add(entity);`
`1463`	`1465`	`}`
`@@ -1480,10 +1482,11 @@ public void Update([NotNull] TEntity entity)`
`1480`	`1482`
`1481`	`1483`	`InterceptError(() => Guard.NotNull(entity, nameof(entity)));`
`1482`	`1484`
`1483`		`- Intercept(x => x.UpdateExecuting(entity));`
`1484`		`-`
`1485`	`1485`	`UseContext(context =>`
`1486`	`1486`	`{`
	`1487`	`+ Intercept(x => x.UpdateExecuting(`
	`1488`	`+ new RepositoryInterceptionContext<TEntity>(entity, context)));`
	`1489`	`+`
`1487`	`1490`	`context.Update(entity);`
`1488`	`1491`	`context.SaveChanges();`
`1489`	`1492`	`});`
`@@ -1507,7 +1510,8 @@ public void Update([NotNull] IEnumerable<TEntity> entities)`
`1507`	`1510`	`{`
`1508`	`1511`	`foreach (var entity in entities)`
`1509`	`1512`	`{`
`1510`		`- Intercept(x => x.UpdateExecuting(entity));`
	`1513`	`+ Intercept(x => x.UpdateExecuting(`
	`1514`	`+ new RepositoryInterceptionContext<TEntity>(entity, context)));`
`1511`	`1515`
`1512`	`1516`	`context.Update(entity);`
`1513`	`1517`	`}`
`@@ -1530,10 +1534,11 @@ public void Delete([NotNull] TEntity entity)`
`1530`	`1534`
`1531`	`1535`	`InterceptError(() => Guard.NotNull(entity, nameof(entity)));`
`1532`	`1536`
`1533`		`- Intercept(x => x.DeleteExecuting(entity));`
`1534`		`-`
`1535`	`1537`	`UseContext(context =>`
`1536`	`1538`	`{`
	`1539`	`+ Intercept(x => x.DeleteExecuting(`
	`1540`	`+ new RepositoryInterceptionContext<TEntity>(entity, context)));`
	`1541`	`+`
`1537`	`1542`	`context.Remove(entity);`
`1538`	`1543`	`context.SaveChanges();`
`1539`	`1544`	`});`
`@@ -1591,7 +1596,8 @@ public void Delete([NotNull] IEnumerable<TEntity> entities)`
`1591`	`1596`	`{`
`1592`	`1597`	`foreach (var entity in entities)`
`1593`	`1598`	`{`
`1594`		`- Intercept(x => x.DeleteExecuting(entity));`
	`1599`	`+ Intercept(x => x.DeleteExecuting(`
	`1600`	`+ new RepositoryInterceptionContext<TEntity>(entity, context)));`
`1595`	`1601`
`1596`	`1602`	`context.Remove(entity);`
`1597`	`1603`	`}`
`@@ -2175,10 +2181,12 @@ Task<int> Getter() =>`
`2175`	`2181`	`cancellationToken.ThrowIfCancellationRequested();`
`2176`	`2182`	`});`
`2177`	`2183`
`2178`		`- await InterceptAsync(x => x.AddExecutingAsync(entity, cancellationToken));`
`2179`		`-`
`2180`	`2184`	`await UseContextAsync(async context =>`
`2181`	`2185`	`{`
	`2186`	`+ await InterceptAsync(x => x.AddExecutingAsync(`
	`2187`	`+ new RepositoryInterceptionContext<TEntity>(entity, context),`
	`2188`	`+ cancellationToken));`
	`2189`	`+`
`2182`	`2190`	`context.Add(entity);`
`2183`	`2191`	`await context.SaveChangesAsync(cancellationToken);`
`2184`	`2192`	`});`
`@@ -2209,7 +2217,9 @@ await UseContextAsync(async context =>`
`2209`	`2217`	`{`
`2210`	`2218`	`foreach (var entity in entities)`
`2211`	`2219`	`{`
`2212`		`- await InterceptAsync(x => x.AddExecutingAsync(entity, cancellationToken));`
	`2220`	`+ await InterceptAsync(x => x.AddExecutingAsync(`
	`2221`	`+ new RepositoryInterceptionContext<TEntity>(entity, context),`
	`2222`	`+ cancellationToken));`
`2213`	`2223`
`2214`	`2224`	`context.Add(entity);`
`2215`	`2225`	`}`
`@@ -2239,10 +2249,12 @@ await UseContextAsync(async context =>`
`2239`	`2249`	`cancellationToken.ThrowIfCancellationRequested();`
`2240`	`2250`	`});`
`2241`	`2251`
`2242`		`- await InterceptAsync(x => x.UpdateExecutingAsync(entity, cancellationToken));`
`2243`		`-`
`2244`	`2252`	`await UseContextAsync(async context =>`
`2245`	`2253`	`{`
	`2254`	`+ await InterceptAsync(x => x.UpdateExecutingAsync(`
	`2255`	`+ new RepositoryInterceptionContext<TEntity>(entity, context),`
	`2256`	`+ cancellationToken));`
	`2257`	`+`
`2246`	`2258`	`context.Update(entity);`
`2247`	`2259`	`await context.SaveChangesAsync(cancellationToken);`
`2248`	`2260`	`});`
`@@ -2273,7 +2285,9 @@ await UseContextAsync(async context =>`
`2273`	`2285`	`{`
`2274`	`2286`	`foreach (var entity in entities)`
`2275`	`2287`	`{`
`2276`		`- await InterceptAsync(x => x.UpdateExecutingAsync(entity, cancellationToken));`
	`2288`	`+ await InterceptAsync(x => x.UpdateExecutingAsync(`
	`2289`	`+ new RepositoryInterceptionContext<TEntity>(entity, context),`
	`2290`	`+ cancellationToken));`
`2277`	`2291`
`2278`	`2292`	`context.Update(entity);`
`2279`	`2293`	`}`
`@@ -2303,10 +2317,12 @@ await UseContextAsync(async context =>`
`2303`	`2317`	`cancellationToken.ThrowIfCancellationRequested();`
`2304`	`2318`	`});`
`2305`	`2319`
`2306`		`- await InterceptAsync(x => x.DeleteExecutingAsync(entity, cancellationToken));`
`2307`		`-`
`2308`	`2320`	`await UseContextAsync(async context =>`
`2309`	`2321`	`{`
	`2322`	`+ await InterceptAsync(x => x.DeleteExecutingAsync(`
	`2323`	`+ new RepositoryInterceptionContext<TEntity>(entity, context),`
	`2324`	`+ cancellationToken));`
	`2325`	`+`
`2310`	`2326`	`context.Remove(entity);`
`2311`	`2327`	`await context.SaveChangesAsync(cancellationToken);`
`2312`	`2328`	`});`
`@@ -2377,7 +2393,9 @@ await UseContextAsync(async context =>`
`2377`	`2393`	`{`
`2378`	`2394`	`foreach (var entity in entities)`
`2379`	`2395`	`{`
`2380`		`- await InterceptAsync(x => x.DeleteExecutingAsync(entity, cancellationToken));`
	`2396`	`+ await InterceptAsync(x => x.DeleteExecutingAsync(`
	`2397`	`+ new RepositoryInterceptionContext<TEntity>(entity, context),`
	`2398`	`+ cancellationToken));`
`2381`	`2399`
`2382`	`2400`	`context.Remove(entity);`
`2383`	`2401`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,9 +23,9 @@ public TestRepositoryTimeStampInterceptor(string loggedInUser)`
`23`	`23`	`_user = loggedInUser;`
`24`	`24`	`}`
`25`	`25`
`26`		`- public override void AddExecuting<TEntity>(TEntity entity)`
	`26`	`+ public override void AddExecuting<TEntity>(RepositoryInterceptionContext<TEntity> interceptionContext)`
`27`	`27`	`{`
`28`		`- if (entity is IHaveTimeStamp haveStamp)`
	`28`	`+ if (interceptionContext.Entity is IHaveTimeStamp haveStamp)`
`29`	`29`	`{`
`30`	`30`	`var currentTime = DateTime.UtcNow;`
`31`	`31`
`@@ -36,9 +36,9 @@ public override void AddExecuting<TEntity>(TEntity entity)`
`36`	`36`	`}`
`37`	`37`	`}`
`38`	`38`
`39`		`- public override void UpdateExecuting<TEntity>(TEntity entity)`
	`39`	`+ public override void UpdateExecuting<TEntity>(RepositoryInterceptionContext<TEntity> interceptionContext)`
`40`	`40`	`{`
`41`		`- if (entity is IHaveTimeStamp haveStamp)`
	`41`	`+ if (interceptionContext.Entity is IHaveTimeStamp haveStamp)`
`42`	`42`	`{`
`43`	`43`	`var currentTime = DateTime.UtcNow;`
`44`	`44`
`@@ -47,9 +47,9 @@ public override void UpdateExecuting<TEntity>(TEntity entity)`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
`50`		`- public override Task AddExecutingAsync<TEntity>(TEntity entity, CancellationToken cancellationToken = new CancellationToken())`
	`50`	`+ public override Task AddExecutingAsync<TEntity>(RepositoryInterceptionContext<TEntity> interceptionContext, CancellationToken cancellationToken = new CancellationToken())`
`51`	`51`	`{`
`52`		`- if (entity is IHaveTimeStamp haveStamp)`
	`52`	`+ if (interceptionContext.Entity is IHaveTimeStamp haveStamp)`
`53`	`53`	`{`
`54`	`54`	`var currentTime = DateTime.UtcNow;`
`55`	`55`
`@@ -62,9 +62,9 @@ public override void UpdateExecuting<TEntity>(TEntity entity)`
`62`	`62`	`return Task.FromResult(0);`
`63`	`63`	`}`
`64`	`64`
`65`		`- public override Task UpdateExecutingAsync<TEntity>(TEntity entity, CancellationToken cancellationToken = new CancellationToken())`
	`65`	`+ public override Task UpdateExecutingAsync<TEntity>(RepositoryInterceptionContext<TEntity> interceptionContext, CancellationToken cancellationToken = new CancellationToken())`
`66`	`66`	`{`
`67`		`- if (entity is IHaveTimeStamp haveStamp)`
	`67`	`+ if (interceptionContext.Entity is IHaveTimeStamp haveStamp)`
`68`	`68`	`{`
`69`	`69`	`var currentTime = DateTime.UtcNow;`
`70`	`70`