Placement match providers

src/OrchardCore.Modules/OrchardCore.Contents/Placement/DefaultPlacementParseMatchProviders.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using OrchardCore.ContentManagement;
+using OrchardCore.DisplayManagement.Descriptors;
+using OrchardCore.DisplayManagement.Descriptors.ShapePlacementStrategy;
+using OrchardCore.DisplayManagement.Shapes;
+
+namespace OrchardCore.Contents.Placement
+{
+    public enum MatchType
+    {
+        Any,
+        All
+    }
+
+    public class ContentPartPlacementParseMatchOptions
+    {
+        [JsonProperty(PropertyName = "parts")]
+        public IEnumerable<string> Parts { get; set; }
+
+        [JsonProperty(PropertyName = "matchType")]
+        public MatchType MatchType { get; set; }
+    }
+
+    public class ContentPartPlacementParseMatchProvider : ContentPlacementParseMatchProviderBase, IPlacementParseMatchProvider
+    {
+        public string Key { get { return "contentPart"; } }
+
+        public bool Match(ShapePlacementContext context, JToken expression)
+        {
+            var contentItem = GetContent(context);
+            if (contentItem == null)
+            {
+                return false;
+            }
+
+            var options = expression.ToObject<ContentPartPlacementParseMatchOptions>();
+
+            return options.MatchType == MatchType.All ? options.Parts.All(p => contentItem.Has(p)) : options.Parts.Any(p => contentItem.Has(p));
+        }
+    }
+
+    public class ContentTypePlacementParseMatchProvider : ContentPlacementParseMatchProviderBase, IPlacementParseMatchProvider
+    {
+        public string Key { get { return "contentType"; } }
+
+        public bool Match(ShapePlacementContext context, JToken expression)
+        {
+            var contentItem = GetContent(context);
+            if (contentItem == null)
+            {
+                return false;
+            }
+
+            var contentTypes = expression.ToObject<IEnumerable<string>>();
+
+            return contentTypes.Any(ct =>
+            {
+                if (ct.EndsWith("*"))
+                {
+                    var prefix = ct.Substring(0, ct.Length - 1);
+
+                    return (contentItem?.ContentType ?? "").StartsWith(prefix);// || (context.Stereotype ?? "").StartsWith(prefix);
+                }
+
+                return contentItem.ContentType == ct;// || context.Stereotype == expression;
+            });
+        }
+    }
+
+    public class ContentPlacementParseMatchProviderBase
+    {
+        protected bool HasContent(ShapePlacementContext context)
+        {
+            var shape = context.ZoneShape as Shape;
+            return shape != null && shape.Properties["ContentItem"] != null;
+        }
+
+        protected ContentItem GetContent(ShapePlacementContext context)
+        {
+            if (!HasContent(context))
+            {
+                return null;
+            }
+
+            var shape = context.ZoneShape as Shape;
+            return shape.Properties["ContentItem"] as ContentItem;
+        }
+    }
+}

src/OrchardCore.Modules/OrchardCore.Contents/Startup.cs

@@ -13,6 +13,7 @@
 using OrchardCore.Contents.Indexing;
 using OrchardCore.Contents.Liquid;
 using OrchardCore.Contents.Models;
+using OrchardCore.Contents.Placement;
 using OrchardCore.Contents.Recipes;
 using OrchardCore.Contents.Services;
 using OrchardCore.Contents.TagHelpers;
@@ -21,6 +22,7 @@
 using OrchardCore.Deployment;
 using OrchardCore.DisplayManagement.Descriptors;
 using OrchardCore.DisplayManagement.Handlers;
+using OrchardCore.DisplayManagement.Descriptors.ShapePlacementStrategy;
 using OrchardCore.Entities;
 using OrchardCore.Navigation;
 using OrchardCore.Feeds;
@@ -66,7 +68,11 @@ public override void ConfigureServices(IServiceCollection services)
             // TODO: Move to feature
             services.AddScoped<IFeedItemBuilder, CommonFeedItemBuilder>();
 
+
             services.AddTagHelpers<ContentLinkTagHelper>();
+
+            services.AddScoped<IPlacementParseMatchProvider, ContentTypePlacementParseMatchProvider>();
+            services.AddScoped<IPlacementParseMatchProvider, ContentPartPlacementParseMatchProvider>();
         }
 
         public override void Configure(IApplicationBuilder builder, IRouteBuilder routes, IServiceProvider serviceProvider)

src/OrchardCore/OrchardCore.DisplayManagement/Descriptors/ShapeAlterationBuilder.cs

@@ -224,7 +224,7 @@ public ShapePlacementContext(string shapeType, string displayType, string differ
             ShapeType = shapeType;
             DisplayType = displayType;
             Differentiator = differentiator;
-            ZoneShape = ZoneShape;
+            ZoneShape = zoneShape;
         }
 
         public IShape ZoneShape { get; set; }

src/OrchardCore/OrchardCore.DisplayManagement/Descriptors/ShapePlacementStrategy/IPlacementParseMatchProvider.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Newtonsoft.Json.Linq;
+
+namespace OrchardCore.DisplayManagement.Descriptors.ShapePlacementStrategy
+{
+    public interface IPlacementParseMatchProvider
+    {
+        string Key { get; }
+        bool Match(ShapePlacementContext context, JToken expression);
+    }
+}

src/OrchardCore/OrchardCore.DisplayManagement/Descriptors/ShapePlacementStrategy/PlacementFile.cs

@@ -1,5 +1,6 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 
 namespace OrchardCore.DisplayManagement.Descriptors.ShapePlacementStrategy
 {
@@ -27,5 +28,8 @@ public class PlacementNode
         [JsonProperty(PropertyName = "shape")]
         public string ShapeType { get; set; }
 
+        [JsonProperty(PropertyName = "match")]
+        public IDictionary<string, JToken> Match { get; set; } = new Dictionary<string, JToken>();
+
     }
 }

src/OrchardCore/OrchardCore.DisplayManagement/Descriptors/ShapePlacementStrategy/ShapePlacementParsingStrategy.cs

@@ -1,9 +1,11 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 using OrchardCore.DisplayManagement.Shapes;
 using OrchardCore.Environment.Extensions;
 using OrchardCore.Environment.Extensions.Features;
@@ -19,15 +21,18 @@ public class ShapePlacementParsingStrategy : IShapeTableHarvester
         private readonly IHostingEnvironment _hostingEnviroment;
         private readonly IShellFeaturesManager _shellFeaturesManager;
         private readonly ILogger _logger;
+        private readonly IEnumerable<IPlacementParseMatchProvider> _placementParseMatchProviders;
 
         public ShapePlacementParsingStrategy(
             IHostingEnvironment hostingEnviroment,
             IShellFeaturesManager shellFeaturesManager,
-            ILogger<ShapePlacementParsingStrategy> logger)
+            ILogger<ShapePlacementParsingStrategy> logger,
+            IEnumerable<IPlacementParseMatchProvider> placementParseMatchProviders)
         {
             _logger = logger;
             _hostingEnviroment = hostingEnviroment;
             _shellFeaturesManager = shellFeaturesManager;
+            _placementParseMatchProviders = placementParseMatchProviders;
         }
 
         public void Discover(ShapeTableBuilder builder)
@@ -70,12 +75,20 @@ private void ProcessPlacementFile(ShapeTableBuilder builder, IFeatureInfo featur
             foreach (var entry in placementFile)
             {
                 var shapeType = entry.Key;
-                var matches = entry.Value;
-
 
                 foreach (var filter in entry.Value)
                 {
+                    var matches = filter.Match.ToList();
+
+                    Func<ShapePlacementContext, bool> predicate = ctx => CheckFilter(ctx, filter);
+
+                    if (matches.Any())
+                    {
+                        predicate = matches.Aggregate(predicate, BuildPredicate);
+                    }
+
                     var placement = new PlacementInfo();
+
                     placement.Location = filter.Location;
                     if (filter.Alternates?.Length > 0)
                     {
@@ -91,7 +104,7 @@ private void ProcessPlacementFile(ShapeTableBuilder builder, IFeatureInfo featur
 
                     builder.Describe(shapeType)
                         .From(featureDescriptor)
-                        .Placement(ctx => CheckFilter(ctx, filter), placement);
+                        .Placement(ctx => predicate(ctx), placement);
                 }
             }
         }
@@ -145,5 +158,27 @@ public static bool CheckFilter(ShapePlacementContext ctx, PlacementNode filter)
             //return ctx => (ctx.Path.Equals(normalizedPath, StringComparison.OrdinalIgnoreCase)) && predicate(ctx);
             //}
         }
+
+        private Func<ShapePlacementContext, bool> BuildPredicate(Func<ShapePlacementContext, bool> predicate,
+              KeyValuePair<string, JToken> term)
+        {
+            return BuildPredicate(predicate, term, _placementParseMatchProviders);
+        }
+
+        public static Func<ShapePlacementContext, bool> BuildPredicate(Func<ShapePlacementContext, bool> predicate,
+                KeyValuePair<string, JToken> term, IEnumerable<IPlacementParseMatchProvider> placementMatchProviders)
+        {
+
+            if (placementMatchProviders != null)
+            {
+                var providersForTerm = placementMatchProviders.Where(x => x.Key.Equals(term.Key));
+                if (providersForTerm.Any())
+                {
+                    var expression = term.Value;
+                    return ctx => providersForTerm.Any(x => x.Match(ctx, expression)) && predicate(ctx);
+                }
+            }
+            return predicate;
+        }
     }
 }

src/OrchardCore/OrchardCore.DisplayManagement/README.md

@@ -29,6 +29,12 @@ Currently you can filter shapes by:
 - Their original type, which is the property name of the placement rule, like `TextField`.
 - `display-type` (Optional): The display type, like `Summary` and `Detail` for the most common ones.
 - `differentiator` (Optional): The differentiator which is used to distinguish shape types that are reused for multiple elements, like field names.
+- `match` (Optional): Custom match providers implementing `IPlacementParseMatchProvider`. 
+
+For shapes that are built from a content item, you can filter by the following built in match providers:
+
+- `contentType` (Optional): An array of ContentTypes that content item from which the shape was built should match.
+- `contentPart` (Optional): An array of ContentParts that content item from which the shape was built should contain (With the option for matching one or all).
 
 Placement information consists of:
 
@@ -44,6 +50,12 @@ Placement information consists of:
 		"display-type": "Detail",
 		"differentiator": "Article-MyTextField",
 
+        "match": {
+            "contentType": [ "Page" ],
+            "contentPart": {
+              "parts": ["BodyPart","TitlePart"],
+              "matchType": "Any"
+            }
 		"place": "Content",
 		"alternates": [ "TextField_Title" ],
 		"wrappers": [ "TextField_Title" ],