Added Policies

Author: adimiko

samples/EasyWay.Samples/Commands/SampleCommandHandler.cs

@@ -1,4 +1,5 @@
 using EasyWay.Samples.Domain;
+using EasyWay.Samples.Domain.Policies;
 
 namespace EasyWay.Samples.Commands
 {
@@ -14,24 +15,33 @@ internal sealed class SampleCommandHandler : ICommandHandler<SampleModule, Sampl
 
         private readonly IConcurrencyConflictValidator _concurrencyTokenValidator;
 
+        private readonly IEnumerable<ISamplePolicy> _policies;
+
         public SampleCommandHandler(
             ICancellationContext cancellationContext,
             ISampleAggragateRootRepository repository,
             SampleAggregateRootFactory factory,
             SampleDomainService domainService,
-            IConcurrencyConflictValidator concurrencyTokenValidator)
+            IConcurrencyConflictValidator concurrencyTokenValidator,
+            IEnumerable<ISamplePolicy> policies)
         {
             _cancellationContext = cancellationContext;
             _repository = repository;
             _factory = factory;
             _domainService = domainService;
             _concurrencyTokenValidator = concurrencyTokenValidator;
+            _policies = policies;
         }
 
         public async Task Handle(SampleCommand command)
         {
             var token = _cancellationContext.Token;
 
+            var data = _policies
+                .Where(x => x.IsApplicable(true))
+                .Single()
+                .Execute("DATA");
+
             var x = _factory.Create();
 
             _concurrencyTokenValidator.Validate(x, command);

samples/EasyWay.Samples/Domain/Policies/ISamplePolicy.cs

@@ -0,0 +1,4 @@
+namespace EasyWay.Samples.Domain.Policies
+{
+    public interface ISamplePolicy : IPolicy<bool, string, string>;
+}

samples/EasyWay.Samples/Domain/Policies/SamplePolicy1.cs

@@ -0,0 +1,12 @@
+namespace EasyWay.Samples.Domain.Policies
+{
+    public sealed class SamplePolicy1 : ISamplePolicy
+    {
+        public string Execute(string data)
+        {
+            return data;
+        }
+
+        public bool IsApplicable(bool data) => true;
+    }
+}

samples/EasyWay.Samples/Domain/Policies/SamplePolicy2.cs

@@ -0,0 +1,12 @@
+namespace EasyWay.Samples.Domain.Policies
+{
+    public sealed class SamplePolicy2 : ISamplePolicy
+    {
+        public string Execute(string data)
+        {
+            return data;
+        }
+
+        public bool IsApplicable(bool data) => false;
+    }
+}

source/EasyWay/IPolicy.cs

@@ -0,0 +1,16 @@
+namespace EasyWay
+{
+    public interface IPolicy<TConditionalData, TInputData>
+    {
+        bool IsApplicable(TConditionalData data);
+
+        void Execute(TInputData data);
+    }
+
+    public interface IPolicy<TConditionalData, TInputData, TOutputData>
+    {
+        bool IsApplicable(TConditionalData data);
+
+        TOutputData Execute(TInputData data);
+    }
+}

source/EasyWay/Internals/Extensions.cs

@@ -3,6 +3,7 @@
 using EasyWay.Internals.DomainEvents;
 using EasyWay.Internals.DomainServices;
 using EasyWay.Internals.Factories;
+using EasyWay.Internals.Policies;
 using EasyWay.Internals.Queries;
 using EasyWay.Internals.Repositories;
 using Microsoft.Extensions.DependencyInjection;
@@ -21,6 +22,7 @@ internal static void AddEasyWay<TModule>(this IServiceCollection services, IEnum
                 .AddQueries<TModule>(assemblies)
                 .AddDomainEvents(assemblies)
                 .AddRepositories(assemblies)
+                .AddPolicies(assemblies)
                 .AddDomainServices(assemblies)
                 .AddFactories(assemblies);
         }

source/EasyWay/Internals/Policies/Extensions.cs

@@ -0,0 +1,25 @@
+using Microsoft.Extensions.DependencyInjection;
+using System.Reflection;
+
+namespace EasyWay.Internals.Policies
+{
+    internal static class Extensions
+    {
+        internal static IServiceCollection AddPolicies(
+            this IServiceCollection services,
+            IEnumerable<Assembly> assemblies) 
+        {
+            services.Scan(s => s.FromAssemblies(assemblies)
+                .AddClasses(c => c.AssignableTo(typeof(IPolicy<,>)))
+                .AsImplementedInterfaces()
+                .WithTransientLifetime());
+
+            services.Scan(s => s.FromAssemblies(assemblies)
+                .AddClasses(c => c.AssignableTo(typeof(IPolicy<,,>)))
+                .AsImplementedInterfaces()
+                .WithTransientLifetime());
+
+            return services;
+        }
+    }
+}