Add full_text_aspect liquid filter

src/OrchardCore.Modules/OrchardCore.Contents/Handlers/FullTextAspectSettingsHandler.cs → src/OrchardCore.Modules/OrchardCore.Contents/Handlers/FullTextAspectContentHandler.cs

@@ -16,13 +16,13 @@ namespace OrchardCore.Contents.Handlers
     /// <summary>
     /// Provides the content for FullTextAspect based on FullTextAspectSettings
     /// </summary>
-    public class FullTextAspectSettingsHandler : ContentHandlerBase
+    public class FullTextAspectContentHandler : ContentHandlerBase
     {
         private readonly IContentDefinitionManager _contentDefinitionManager;
         private readonly ILiquidTemplateManager _liquidTemplateManager;
         private readonly IServiceProvider _serviceProvider;
 
-        public FullTextAspectSettingsHandler(
+        public FullTextAspectContentHandler(
             IContentDefinitionManager contentDefinitionManager,
             ILiquidTemplateManager liquidTemplateManager,
             IServiceProvider serviceProvider

src/OrchardCore.Modules/OrchardCore.Contents/Indexing/FullTextContentIndexHandler.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Threading.Tasks;
 using OrchardCore.ContentManagement;
 using OrchardCore.ContentManagement.Models;
@@ -21,10 +22,13 @@ public async Task BuildIndexAsync(BuildIndexContext context)
             // Index each segment as a new value to prevent from allocation a new string
             foreach (var segment in result.Segments)
             {
-                context.DocumentIndex.Set(
-                    IndexingConstants.FullTextKey,
-                    segment,
-                    DocumentIndexOptions.Analyze | DocumentIndexOptions.Sanitize);
+                if (!String.IsNullOrEmpty(segment))
+                {
+                    context.DocumentIndex.Set(
+                        IndexingConstants.FullTextKey,
+                        segment,
+                        DocumentIndexOptions.Analyze | DocumentIndexOptions.Sanitize);
+                }
             }
         }
     }

src/OrchardCore.Modules/OrchardCore.Contents/Liquid/BuildDisplayFilter.cs

@@ -45,9 +45,19 @@ static async ValueTask<FluidValue> Awaited(Task<IShape> task)
                 throw new ArgumentException("Services missing while invoking 'shape_build_display'");
             }
 
+            var serviceProvider = (IServiceProvider)services;
+
+            var buildDisplayRecursionHelper = serviceProvider.GetRequiredService<IContentItemRecursionHelper<BuildDisplayFilter>>();
+
+            // When {{ Model.ContentItem | shape_build_display | shape_render }} is called prevent recursion.
+            if (buildDisplayRecursionHelper.IsRecursive(contentItem))
+            {
+                return new ValueTask<FluidValue>(NilValue.Instance);
+            }
+
             var displayType = arguments["type"].Or(arguments.At(0)).ToStringValue();
-            var displayManager = ((IServiceProvider)services).GetRequiredService<IContentItemDisplayManager>();
-            var updateModelAccessor = ((IServiceProvider)services).GetRequiredService<IUpdateModelAccessor>();
+            var displayManager = serviceProvider.GetRequiredService<IContentItemDisplayManager>();
+            var updateModelAccessor = serviceProvider.GetRequiredService<IUpdateModelAccessor>();
 
             var task = displayManager.BuildDisplayAsync(contentItem, updateModelAccessor.ModelUpdater, displayType);
             if (task.IsCompletedSuccessfully)

src/OrchardCore.Modules/OrchardCore.Contents/Liquid/ContentItemRecursionHelper.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using OrchardCore.ContentManagement;
+using OrchardCore.Liquid;
+
+namespace OrchardCore.Contents.Liquid
+{
+    /// <summary>
+    /// Prevents a content item being called by an implementation of a <see cref="ILiquidFilter"/> recursivly.
+    /// </summary>
+    public interface IContentItemRecursionHelper<T> where T : ILiquidFilter
+    {
+        /// <summary>
+        /// Returns <see langword="True"/> when the <see cref="ContentItem"/> has already been evaluated during this request by the particular filter./>
+        /// </summary>
+        bool IsRecursive(ContentItem contentItem);
+    }
+
+    /// <inheritdocs />
+    public class ContentItemRecursionHelper<T> : IContentItemRecursionHelper<T> where T : ILiquidFilter
+    {
+        private HashSet<string> _contentItemIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+        /// <inheritdocs />
+        public bool IsRecursive(ContentItem contentItem)
+        {
+            if (_contentItemIds.Contains(contentItem.ContentItemId))
+            {
+                return true;
+            }
+
+            _contentItemIds.Add(contentItem.ContentItemId);
+
+            return false;
+        }
+    }
+}

src/OrchardCore.Modules/OrchardCore.Contents/Liquid/FullTextFilter.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Fluid;
+using Fluid.Values;
+using Microsoft.Extensions.DependencyInjection;
+using Newtonsoft.Json.Linq;
+using OrchardCore.ContentManagement;
+using OrchardCore.ContentManagement.Models;
+using OrchardCore.Liquid;
+
+namespace OrchardCore.Contents.Liquid
+{
+    public class FullTextFilter : ILiquidFilter
+    {
+        public async ValueTask<FluidValue> ProcessAsync(FluidValue input, FilterArguments arguments, TemplateContext ctx)
+        {
+            if (!ctx.AmbientValues.TryGetValue("Services", out var services))
+            {
+                throw new ArgumentException("Services missing while invoking 'full_text_aspect'");
+            }
+
+            var serviceProvider = (IServiceProvider)services;
+
+            var contentManager = serviceProvider.GetRequiredService<IContentManager>();
+            var fullTextRecursionHelper = serviceProvider.GetRequiredService<IContentItemRecursionHelper<FullTextFilter>>();
+
+            if (input.Type == FluidValues.Array)
+            {
+                var contentItems = new List<ContentItem>();
+                foreach(var objValue in input.Enumerate())
+                {
+                    var contentItem = GetContentItem(objValue);
+                    if (contentItem != null)
+                    {
+                        if (!fullTextRecursionHelper.IsRecursive(contentItem))
+                        {
+                            contentItems.Add(contentItem);
+                        }
+                    }
+                }
+
+                if (!contentItems.Any())
+                {
+                    return NilValue.Instance;
+                }
+
+                var aspects = new List<FullTextAspect>();
+
+                foreach(var contentItem in contentItems)
+                {
+                    aspects.Add(await contentManager.PopulateAspectAsync<FullTextAspect>(contentItem));
+                }
+
+                // When returning segments seperate them so multiple segments are indexed individually.
+                return new ArrayValue(aspects.SelectMany(x => x.Segments).Where(x => !String.IsNullOrEmpty(x)).Select(x => new StringValue(x + ' ')));
+            }
+            else
+            {
+                var contentItem = GetContentItem(input);
+
+                if (contentItem == null || fullTextRecursionHelper.IsRecursive(contentItem))
+                {
+                    return NilValue.Instance;
+                }
+
+                var fullTextAspect = await contentManager.PopulateAspectAsync<FullTextAspect>(contentItem);
+
+                // Remove empty strings as display text is often unused in contained content items.
+                return new ArrayValue(fullTextAspect.Segments.Where(x => !String.IsNullOrEmpty(x)).Select(x => new StringValue(x)));
+            }
+        }
+
+        private static ContentItem GetContentItem(FluidValue input)
+        {
+            var obj = input.ToObjectValue();
+
+            if (!(obj is ContentItem contentItem))
+            {
+                contentItem = null;
+
+                if (obj is JObject jObject)
+                {
+                    contentItem = jObject.ToObject<ContentItem>();
+                    // If input is a 'JObject' but which not represents a 'ContentItem',
+                    // a 'ContentItem' is still created but with some null properties.
+                    if (contentItem?.ContentItemId == null)
+                    {
+                        return null;
+                    }
+                }
+            }
+
+            return contentItem;
+        }
+    }
+}

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

@@ -104,7 +104,7 @@ public override void ConfigureServices(IServiceCollection services)
 
             // FullTextAspect
             services.AddScoped<IContentTypeDefinitionDisplayDriver, FullTextAspectSettingsDisplayDriver>();
-            services.AddScoped<IContentHandler, FullTextAspectSettingsHandler>();
+            services.AddScoped<IContentHandler, FullTextAspectContentHandler>();
 
             services.AddTagHelpers<ContentLinkTagHelper>();
             services.AddTagHelpers<ContentItemTagHelper>();
@@ -138,6 +138,10 @@ public override void ConfigureServices(IServiceCollection services)
             services.AddLiquidFilter<ContentItemFilter>("content_item_id");
             services.AddLiquidFilter<DisplayTextFilter>("display_text");
             services.AddLiquidFilter<DisplayUrlFilter>("display_url");
+            services.AddLiquidFilter<FullTextFilter>("full_text");
+
+            services.AddScoped<IContentItemRecursionHelper<FullTextFilter>, ContentItemRecursionHelper<FullTextFilter>>();
+            services.AddScoped<IContentItemRecursionHelper<BuildDisplayFilter>, ContentItemRecursionHelper<BuildDisplayFilter>>();
         }
 
         public override void Configure(IApplicationBuilder builder, IEndpointRouteBuilder routes, IServiceProvider serviceProvider)