Merge pull request #111 from dennisdoomen/ExtendedMappingApi

Adds global filters as well as custom handling for duplicates and misses

GitVersion.yml

@@ -0,0 +1,6 @@
+branches: 
+  (pull|pull\-requests|pr)[/-]:
+    mode: ContinuousDeployment
+    tag: pr
+ignore:
+  sha: []

Samples/ExampleHost/ExampleProjector.cs

@@ -27,32 +27,34 @@ public ExampleProjector(IEventMapBuilder<TProjection, string, ProjectionContext>
 
         private IEventMap<ProjectionContext> BuildMapFrom(IEventMapBuilder<TProjection, string, ProjectionContext> mapBuilder)
         {
-            mapBuilder.HandleProjectionModificationsAs((key, context, projector, options) =>
+            return mapBuilder.Build(new ProjectorMap<TProjection, string, ProjectionContext>
             {
-                TProjection projection = store.GetRepository<TProjection>().Find(key);
-                if (projection == null)
+                Create = async (key, context, projector, shouldOverride) =>
                 {
-                    projection = new TProjection()
+                    var projection = new TProjection()
                     {
                         Id = key
                     };
 
-                    store.Add(projection);
-                }
+                    await projector(projection);
 
-                return projector(projection);
-            });
+                    store.Add(projection);
+                },
+                Update = async (key, context, projector, createIfMissing) =>
+                {
+                    TProjection projection = store.GetRepository<TProjection>().Find(key);
+                    await projector(projection);
 
-            mapBuilder.HandleProjectionDeletionsAs((key, context, options) =>
-            {
-                store.GetRepository<TProjection>().RemoveByKey(key);
+                    store.Add(projection);
+                },
+                Delete = (key, context) =>
+                {
+                    store.GetRepository<TProjection>().RemoveByKey(key);
 
-                return Task.FromResult(0);
+                    return Task.FromResult(true);
+                },
+                Custom = (context, projector) => projector()
             });
-
-            mapBuilder.HandleCustomActionsAs((context, projector) => projector());
-
-            return mapBuilder.Build();
         }
 
         public async Task Handle(IReadOnlyList<Transaction> transactions)

Src/LiquidProjections/EventMap.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 
 namespace LiquidProjections
@@ -10,8 +11,8 @@ namespace LiquidProjections
     public class EventMap<TContext> : IEventMap<TContext>
     {
         private readonly Dictionary<Type, List<Handler>> mappings = new Dictionary<Type, List<Handler>>();
-
-        internal CustomHandler<TContext> Do { get; set; }
+        private readonly List<Func<object, TContext, Task<bool>>> filters =
+            new List<Func<object, TContext, Task<bool>>>();
 
         internal void Add<TEvent>(Func<TEvent, TContext, Task> action)
         {
@@ -23,10 +24,12 @@ internal void Add<TEvent>(Func<TEvent, TContext, Task> action)
             mappings[typeof(TEvent)].Add((@event, context) => action((TEvent)@event, context));
         }
 
-        /// <summary>
-        /// Handles <paramref name="anEvent"/> asynchronously using context <paramref name="context"/>.
-        /// </summary>
-        public async Task Handle(object anEvent, TContext context)
+        internal void AddFilter(Func<object, TContext, Task<bool>> filter)
+        {
+            filters.Add(filter);
+        }
+
+        public async Task<bool> Handle(object anEvent, TContext context)
         {
             if (anEvent == null)
             {
@@ -38,17 +41,36 @@ public async Task Handle(object anEvent, TContext context)
                 throw new ArgumentNullException(nameof(context));
             }
 
-            Type key = anEvent.GetType();
-
-            List<Handler> handlers;
-
-            if (mappings.TryGetValue(key, out handlers))
+            if (await PassesFilter(anEvent, context))
             {
-                foreach (Handler handler in handlers)
+                Type key = anEvent.GetType();
+
+                if (mappings.TryGetValue(key, out var handlers))
                 {
-                    await handler(anEvent, context);
+                    foreach (Handler handler in handlers)
+                    {
+                        await handler(anEvent, context);
+                    }
+
+                    return true;
                 }
             }
+
+            return false;
+        }
+
+        private async Task<bool> PassesFilter(object anEvent, TContext context)
+        {
+            if (filters.Count > 0)
+            {
+                bool[] results = await Task.WhenAll(filters.Select(filter => filter(anEvent, context)));
+
+                return results.All(x => x);
+            }
+            else
+            {
+                return true;
+            }
         }
 
         private delegate Task Handler(object @event, TContext context);