Iatsuta/add many relative domain path info (#555)

* add ManyRelativeDomainPathInfo

Author: iatsuta

src/Framework.SecuritySystem.Abstract/Providers/AccessResultExtensions.cs

@@ -1,4 +1,6 @@
-namespace Framework.SecuritySystem;
+using Framework.Core;
+
+namespace Framework.SecuritySystem;
 
 public static class AccessResultExtensions
 {
@@ -14,4 +16,10 @@ public static AccessResult TryOverrideAccessDeniedResult(
             AccessResult.AccessDeniedResult accessDeniedResult => selector(accessDeniedResult),
             _ => accessResult
         };
+
+    public static AccessResult Or(this IEnumerable<AccessResult> source) =>
+        source.Match(
+            () => AccessResult.AccessDeniedResult.Default,
+            result => result,
+            results => results.Aggregate((AccessResult)AccessResult.AccessDeniedResult.Default, (v1, v2) => v1.Or(v2)));
 }

src/Framework.SecuritySystem.Abstract/SecurityAccessor/SecurityAccessorDataExtensions.cs

@@ -0,0 +1,14 @@
+using Framework.Core;
+
+namespace Framework.SecuritySystem;
+
+public static class SecurityAccessorDataExtensions
+{
+    public static SecurityAccessorData Or(this IEnumerable<SecurityAccessorData> source) =>
+        source.Match(
+            () => SecurityAccessorData.Empty,
+            result => result,
+            results => results.Aggregate(
+                SecurityAccessorData.Empty,
+                (v1, v2) => new SecurityAccessorData.OrSecurityAccessorData(v1, v2)));
+}

src/Framework.SecuritySystem.DiTests/Services/TestCheckboxConditionFactory.cs

@@ -9,6 +9,6 @@ public class TestCheckboxConditionFactory<TDomainObject>(IRelativeDomainPathInfo
 {
     public Expression<Func<TDomainObject, bool>> Create()
     {
-        return pathToEmployeeInfo.Path.Select(employee => employee.TestCheckbox);
+        return pathToEmployeeInfo.CreateCondition(employee => employee.TestCheckbox);
     }
 }

src/Framework.SecuritySystem/DependencyInjection/DomainSecurityServiceBuilder/DomainSecurityServiceBuilder.cs

@@ -124,7 +124,7 @@ public IDomainSecurityServiceBuilder<TDomainObject> SetDependency<TSource>(Expre
 
         this.relativePathData =
             (typeof(IRelativeDomainPathInfo<TDomainObject, TSource>),
-                new RelativeDomainPathInfo<TDomainObject, TSource>(relativeDomainPath));
+                new SingleRelativeDomainPathInfo<TDomainObject, TSource>(relativeDomainPath));
 
         return this;
     }

src/Framework.SecuritySystem/DependencyInjection/ServiceCollectionExtensions.cs

@@ -69,7 +69,24 @@ public static IServiceCollection AddRelativeDomainPath<TFrom, TTo>(
         Expression<Func<TFrom, TTo>> path,
         string? key = null)
     {
-        var info = new RelativeDomainPathInfo<TFrom, TTo>(path);
+        var info = new SingleRelativeDomainPathInfo<TFrom, TTo>(path);
+
+        if (key == null)
+        {
+            return services.AddSingleton<IRelativeDomainPathInfo<TFrom, TTo>>(info);
+        }
+        else
+        {
+            return services.AddKeyedSingleton<IRelativeDomainPathInfo<TFrom, TTo>>(key, info);
+        }
+    }
+
+    public static IServiceCollection AddRelativeDomainPath<TFrom, TTo>(
+        this IServiceCollection services,
+        Expression<Func<TFrom, IEnumerable<TTo>>> path,
+        string? key = null)
+    {
+        var info = new ManyRelativeDomainPathInfo<TFrom, TTo>(path);
 
         if (key == null)
         {

src/Framework.SecuritySystem/DomainServices/DependencySecurity/DependencyDomainSecurityService.cs

@@ -7,7 +7,7 @@ public class DependencyDomainSecurityService<TDomainObject, TBaseDomainObject>(
     ISecurityRuleExpander securityRuleExpander,
     IDomainSecurityService<TBaseDomainObject> baseDomainSecurityService,
     IQueryableSource queryableSource,
-    IRelativeDomainPathInfo<TDomainObject, TBaseDomainObject> pathInfo)
+    IRelativeDomainPathInfo<TDomainObject, TBaseDomainObject> relativeDomainPathInfo)
     : DependencyDomainSecurityServiceBase<TDomainObject, TBaseDomainObject>(
         securityRuleExpander,
         baseDomainSecurityService)
@@ -17,7 +17,7 @@ protected override ISecurityProvider<TDomainObject> CreateDependencySecurityProv
     {
         return new DependencySecurityProvider<TDomainObject, TBaseDomainObject>(
             baseProvider,
-            pathInfo.Path,
+            relativeDomainPathInfo,
             queryableSource);
     }
 }

src/Framework.SecuritySystem/Providers/DependencySecurity/DependencySecurityProvider.cs

@@ -1,13 +1,11 @@
-using System.Linq.Expressions;
-
-using Framework.Core;
+using Framework.Core;
 using Framework.QueryableSource;
 
 namespace Framework.SecuritySystem;
 
 public class DependencySecurityProvider<TDomainObject, TBaseDomainObject>(
     ISecurityProvider<TBaseDomainObject> baseSecurityProvider,
-    Expression<Func<TDomainObject, TBaseDomainObject>> selector,
+    IRelativeDomainPathInfo<TDomainObject, TBaseDomainObject> relativePath,
     IQueryableSource queryableSource)
     : ISecurityProvider<TDomainObject>
     where TBaseDomainObject : class
@@ -16,21 +14,25 @@ public IQueryable<TDomainObject> InjectFilter(IQueryable<TDomainObject> queryabl
     {
         var baseDomainObjSecurityQ = queryableSource.GetQueryable<TBaseDomainObject>().Pipe(baseSecurityProvider.InjectFilter);
 
-        return queryable.Where(selector.Select(domainObj => baseDomainObjSecurityQ.Contains(domainObj)));
+        return queryable.Where(relativePath.CreateCondition(domainObj => baseDomainObjSecurityQ.Contains(domainObj)));
     }
 
     public AccessResult GetAccessResult(TDomainObject domainObject)
     {
-        return baseSecurityProvider.GetAccessResult(selector.Eval(domainObject)).TryOverrideDomainObject(domainObject);
+        return relativePath
+               .GetRelativeObjects(domainObject)
+               .Select(baseSecurityProvider.GetAccessResult)
+               .Or()
+               .TryOverrideDomainObject(domainObject);
     }
 
     public bool HasAccess(TDomainObject domainObject)
     {
-        return baseSecurityProvider.HasAccess(selector.Eval(domainObject));
+        return relativePath.GetRelativeObjects(domainObject).Any(baseSecurityProvider.HasAccess);
     }
 
     public SecurityAccessorData GetAccessorData(TDomainObject domainObject)
     {
-        return baseSecurityProvider.GetAccessorData(selector.Eval(domainObject));
+        return relativePath.GetRelativeObjects(domainObject).Select(baseSecurityProvider.GetAccessorData).Or();
     }
 }

src/Framework.SecuritySystem/RelativeDomainPathInfo/IRelativeDomainPathInfo.cs

@@ -4,5 +4,13 @@ namespace Framework.SecuritySystem;
 
 public interface IRelativeDomainPathInfo<TFrom, TTo>
 {
-    Expression<Func<TFrom, TTo>> Path { get; }
+    IRelativeDomainPathInfo<TNewFrom, TTo> OverrideInput<TNewFrom>(Expression<Func<TNewFrom, TFrom>> selector);
+
+    IRelativeDomainPathInfo<TFrom, TNewTo> Select<TNewTo>(Expression<Func<TTo, TNewTo>> selector);
+
+    IRelativeDomainPathInfo<TFrom, TNewTo> Select<TNewTo>(Expression<Func<TTo, IEnumerable<TNewTo>>> selector);
+
+    Expression<Func<TFrom, bool>> CreateCondition(Expression<Func<TTo, bool>> filter);
+
+    IEnumerable<TTo> GetRelativeObjects(TFrom source);
 }

src/Framework.SecuritySystem/RelativeDomainPathInfo/ManyRelativeDomainPathInfo.cs

@@ -0,0 +1,35 @@
+using System.Linq.Expressions;
+
+using Framework.Core;
+
+namespace Framework.SecuritySystem;
+
+public record ManyRelativeDomainPathInfo<TFrom, TTo>(Expression<Func<TFrom, IEnumerable<TTo>>> Path) : IRelativeDomainPathInfo<TFrom, TTo>
+{
+    public IRelativeDomainPathInfo<TNewFrom, TTo> OverrideInput<TNewFrom>(Expression<Func<TNewFrom, TFrom>> selector)
+    {
+        return new ManyRelativeDomainPathInfo<TNewFrom, TTo>(this.Path.OverrideInput(selector));
+    }
+
+    public IRelativeDomainPathInfo<TFrom, TNewTo> Select<TNewTo>(Expression<Func<TTo, TNewTo>> selector)
+    {
+        return new ManyRelativeDomainPathInfo<TFrom, TNewTo>(
+            this.Path.Select(items => items.Select(item => selector.Eval(item))).ExpandConst().InlineEval());
+    }
+
+    public IRelativeDomainPathInfo<TFrom, TNewTo> Select<TNewTo>(Expression<Func<TTo, IEnumerable<TNewTo>>> selector)
+    {
+        return new ManyRelativeDomainPathInfo<TFrom, TNewTo>(
+            this.Path.Select(items => items.SelectMany(item => selector.Eval(item))).ExpandConst().InlineEval());
+    }
+
+    public Expression<Func<TFrom, bool>> CreateCondition(Expression<Func<TTo, bool>> filter)
+    {
+        return this.Path.Select(items => items.Any(item => filter.Eval(item))).ExpandConst().InlineEval();
+    }
+
+    public IEnumerable<TTo> GetRelativeObjects(TFrom source)
+    {
+        return this.Path.Eval(source);
+    }
+}

src/Framework.SecuritySystem/RelativeDomainPathInfo/RelativeDomainPathInfo.cs

@@ -1,5 +1,38 @@
 using System.Linq.Expressions;
 
+using Framework.Core;
+
 namespace Framework.SecuritySystem;
 
-public record RelativeDomainPathInfo<TFrom, TTo>(Expression<Func<TFrom, TTo>> Path) : IRelativeDomainPathInfo<TFrom, TTo>;
+public record SingleRelativeDomainPathInfo<TFrom, TTo>(Expression<Func<TFrom, TTo>> Path) : IRelativeDomainPathInfo<TFrom, TTo>
+{
+    public IRelativeDomainPathInfo<TNewFrom, TTo> OverrideInput<TNewFrom>(Expression<Func<TNewFrom, TFrom>> selector)
+    {
+        return new SingleRelativeDomainPathInfo<TNewFrom, TTo>(this.Path.OverrideInput(selector));
+    }
+
+    public IRelativeDomainPathInfo<TFrom, TNewTo> Select<TNewTo>(Expression<Func<TTo, TNewTo>> selector)
+    {
+        return new SingleRelativeDomainPathInfo<TFrom, TNewTo>(this.Path.Select(selector));
+    }
+
+    public IRelativeDomainPathInfo<TFrom, TNewTo> Select<TNewTo>(Expression<Func<TTo, IEnumerable<TNewTo>>> selector)
+    {
+        return new ManyRelativeDomainPathInfo<TFrom, TNewTo>(this.Path.Select(selector));
+    }
+
+    public Expression<Func<TFrom, bool>> CreateCondition(Expression<Func<TTo, bool>> filter)
+    {
+        return this.Path.Select(filter);
+    }
+
+    public IEnumerable<TTo> GetRelativeObjects(TFrom source)
+    {
+        var relativeObject = this.Path.Eval(source);
+
+        if (relativeObject != null)
+        {
+            yield return relativeObject;
+        }
+    }
+}