Content Picker Search - support allowed content types config

src/Umbraco.Cms.Api.Management/Controllers/Document/Item/SearchDocumentItemController.cs

@@ -1,4 +1,5 @@
-using Asp.Versioning;
+using System.Text.Json.Serialization;
+using Asp.Versioning;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Umbraco.Cms.Api.Management.Factories;
@@ -26,12 +27,17 @@
     public async Task<IActionResult> Search(CancellationToken cancellationToken, string query, int skip = 0, int take = 100)
         => await SearchFromParent(cancellationToken, query, skip, take);
 
+    [NonAction]
+    [Obsolete("Scheduled to be removed in v16, use the non obsoleted method instead")]
+    public async Task<IActionResult> SearchFromParent(CancellationToken cancellationToken, string query, int skip = 0, int take = 100, Guid? parentId = null)
+        => await SearchFromParentWithAllowedTypes(cancellationToken, query, skip, take, parentId);
+
     [HttpGet("search")]
     [MapToApiVersion("1.0")]
     [ProducesResponseType(typeof(PagedModel<DocumentItemResponseModel>), StatusCodes.Status200OK)]
-    public async Task<IActionResult> SearchFromParent(CancellationToken cancellationToken, string query, int skip = 0, int take = 100, Guid? parentId = null)
+    public async Task<IActionResult> SearchFromParentWithAllowedTypes(CancellationToken cancellationToken, string query, int skip = 0, int take = 100, Guid? parentId = null, [FromQuery]IEnumerable<Guid>? allowedDocumentTypes = null)
     {
-        PagedModel<IEntitySlim> searchResult = _indexedEntitySearchService.Search(UmbracoObjectTypes.Document, query, parentId, skip, take);
+        PagedModel<IEntitySlim> searchResult = _indexedEntitySearchService.Search(UmbracoObjectTypes.Document, query, parentId, allowedDocumentTypes, skip, take);
         var result = new PagedModel<DocumentItemResponseModel>
         {
             Items = searchResult.Items.OfType<IDocumentEntitySlim>().Select(_documentPresentationFactory.CreateItemResponseModel),

src/Umbraco.Cms.Api.Management/Controllers/Media/Item/SearchMediaItemController.cs

@@ -26,12 +26,18 @@
     public async Task<IActionResult> Search(CancellationToken cancellationToken, string query, int skip = 0, int take = 100)
         => await SearchFromParent(cancellationToken, query, skip, take, null);
 
+    [NonAction]
+    [Obsolete("Scheduled to be removed in v16, use the non obsoleted method instead")]
+    [ProducesResponseType(typeof(PagedModel<MediaItemResponseModel>), StatusCodes.Status200OK)]
+    public async Task<IActionResult> SearchFromParent(CancellationToken cancellationToken, string query, int skip = 0, int take = 100, Guid? parentId = null)
+        => await SearchFromParentWithAllowedTypes(cancellationToken, query, skip, take, parentId);
+
     [HttpGet("search")]
     [MapToApiVersion("1.0")]
     [ProducesResponseType(typeof(PagedModel<MediaItemResponseModel>), StatusCodes.Status200OK)]
-    public async Task<IActionResult> SearchFromParent(CancellationToken cancellationToken, string query, int skip = 0, int take = 100, Guid? parentId = null)
+    public async Task<IActionResult> SearchFromParentWithAllowedTypes(CancellationToken cancellationToken, string query, int skip = 0, int take = 100, Guid? parentId = null, [FromQuery]IEnumerable<Guid>? allowedMediaTypes = null)
     {
-        PagedModel<IEntitySlim> searchResult = _indexedEntitySearchService.Search(UmbracoObjectTypes.Media, query, parentId, skip, take);
+        PagedModel<IEntitySlim> searchResult = _indexedEntitySearchService.Search(UmbracoObjectTypes.Media, query, parentId, allowedMediaTypes, skip, take);
         var result = new PagedModel<MediaItemResponseModel>
         {
             Items = searchResult.Items.OfType<IMediaEntitySlim>().Select(_mediaPresentationFactory.CreateItemResponseModel),

src/Umbraco.Cms.Api.Management/Controllers/Member/Item/SearchMemberItemController.cs

@@ -21,12 +21,17 @@
         _memberPresentationFactory = memberPresentationFactory;
     }
 
+    [NonAction]
+    [Obsolete("Scheduled to be removed in v16, use the non obsoleted method instead")]
+    public async Task<IActionResult> Search(CancellationToken cancellationToken, string query, int skip = 0, int take = 100)
+        => await SearchWithAllowedTypes(cancellationToken, query, skip, take);
+
     [HttpGet("search")]
     [MapToApiVersion("1.0")]
     [ProducesResponseType(typeof(PagedModel<MemberItemResponseModel>), StatusCodes.Status200OK)]
-    public async Task<IActionResult> Search(CancellationToken cancellationToken, string query, int skip = 0, int take = 100)
+    public async Task<IActionResult> SearchWithAllowedTypes(CancellationToken cancellationToken, string query, int skip = 0, int take = 100, [FromQuery]IEnumerable<Guid>? allowedMemberTypes = null)
     {
-        PagedModel<IEntitySlim> searchResult = _indexedEntitySearchService.Search(UmbracoObjectTypes.Member, query, skip, take);
+        PagedModel<IEntitySlim> searchResult = _indexedEntitySearchService.Search(UmbracoObjectTypes.Member, query, null, allowedMemberTypes, skip, take);
         var result = new PagedModel<MemberItemResponseModel>
         {
             Items = searchResult.Items.OfType<IMemberEntitySlim>().Select(_memberPresentationFactory.CreateItemResponseModel),

src/Umbraco.Cms.Api.Management/OpenApi.json

@@ -10086,6 +10086,17 @@
               "type": "string",
               "format": "uuid"
             }
+          },
+          {
+            "name": "allowedDocumentTypes",
+            "in": "query",
+            "schema": {
+              "type": "array",
+              "items": {
+                "type": "string",
+                "format": "uuid"
+              }
+            }
           }
         ],
         "responses": {
@@ -15764,6 +15775,17 @@
               "type": "string",
               "format": "uuid"
             }
+          },
+          {
+            "name": "allowedMediaTypes",
+            "in": "query",
+            "schema": {
+              "type": "array",
+              "items": {
+                "type": "string",
+                "format": "uuid"
+              }
+            }
           }
         ],
         "responses": {
@@ -19638,6 +19660,17 @@
               "format": "int32",
               "default": 100
             }
+          },
+          {
+            "name": "allowedMemberTypes",
+            "in": "query",
+            "schema": {
+              "type": "array",
+              "items": {
+                "type": "string",
+                "format": "uuid"
+              }
+            }
           }
         ],
         "responses": {

src/Umbraco.Core/Services/IIndexedEntitySearchService.cs

@@ -12,9 +12,15 @@
 /// </remarks>
 public interface IIndexedEntitySearchService
 {
+    [Obsolete("Please use the method that accepts all parameters. Will be removed in V17.")]
     PagedModel<IEntitySlim> Search(UmbracoObjectTypes objectType, string query, int skip = 0, int take = 100, bool ignoreUserStartNodes = false);
 
     // default implementation to avoid breaking changes falls back to old behaviour
+    [Obsolete("Please use the method that accepts all parameters. Will be removed in V17.")]
     PagedModel<IEntitySlim> Search(UmbracoObjectTypes objectType, string query, Guid? parentId, int skip = 0, int take = 100, bool ignoreUserStartNodes = false)
         => Search(objectType,query, skip, take, ignoreUserStartNodes);
+
+    // default implementation to avoid breaking changes falls back to old behaviour
+    PagedModel<IEntitySlim> Search(UmbracoObjectTypes objectType, string query, Guid? parentId, IEnumerable<Guid>? contentTypeIds, int skip = 0, int take = 100, bool ignoreUserStartNodes = false)
+        => Search(objectType,query, skip, take, ignoreUserStartNodes);
 }

src/Umbraco.Examine.Lucene/BackOfficeExamineSearcher.cs

@@ -1,4 +1,4 @@
 // Copyright (c) Umbraco.
 // See LICENSE for more details.
 
 using System.Globalization;
@@ -52,6 +52,7 @@
         _publishedUrlProvider = publishedUrlProvider;
     }
 
+    [Obsolete("Please use the method that accepts all parameters. Will be removed in V17.")]
     public IEnumerable<ISearchResult> Search(
         string query,
         UmbracoEntityTypes entityType,
@@ -60,87 +61,103 @@
         out long totalFound,
         string? searchFrom = null,
         bool ignoreUserStartNodes = false)
+        => Search(query, entityType, pageSize, pageIndex, out totalFound, null, searchFrom, ignoreUserStartNodes);
+
+    public IEnumerable<ISearchResult> Search(
+        string query,
+        UmbracoEntityTypes entityType,
+        int pageSize,
+        long pageIndex,
+        out long totalFound,
+        string[]? contentTypeAliases = null,
+        string? searchFrom = null,
+        bool ignoreUserStartNodes = false)
     {
         var sb = new StringBuilder();
 
         string type;
         var indexName = Constants.UmbracoIndexes.InternalIndexName;
         var fields = _treeSearcherFields.GetBackOfficeFields().ToList();
 
         ISet<string> fieldsToLoad = new HashSet<string>(_treeSearcherFields.GetBackOfficeFieldsToLoad());
 
         // TODO: WE should try to allow passing in a lucene raw query, however we will still need to do some manual string
         // manipulation for things like start paths, member types, etc...
         //if (Examine.ExamineExtensions.TryParseLuceneQuery(query))
         //{
 
         //}
 
         //special GUID check since if a user searches on one specifically we need to escape it
         if (Guid.TryParse(query, out Guid g))
         {
             query = "\"" + g + "\"";
         }
         else
         {
             // No Guid so no need to search the __Key field to prevent irrelevant results
             fields.Remove(UmbracoExamineFieldNames.NodeKeyFieldName);
         }
 
         IUser? currentUser = _backOfficeSecurityAccessor?.BackOfficeSecurity?.CurrentUser;
 
         switch (entityType)
         {
             case UmbracoEntityTypes.Member:
                 indexName = Constants.UmbracoIndexes.MembersIndexName;
                 type = "member";
                 fields.AddRange(_treeSearcherFields.GetBackOfficeMembersFields());
                 foreach (var field in _treeSearcherFields.GetBackOfficeMembersFieldsToLoad())
                 {
                     fieldsToLoad.Add(field);
                 }
 
                 if (searchFrom != null && searchFrom != Constants.Conventions.MemberTypes.AllMembersListId &&
                     searchFrom.Trim() != "-1")
                 {
                     sb.Append("+__NodeTypeAlias:");
                     sb.Append(searchFrom);
                     sb.Append(" ");
                 }
 
                 break;
             case UmbracoEntityTypes.Media:
                 type = "media";
                 fields.AddRange(_treeSearcherFields.GetBackOfficeMediaFields());
                 foreach (var field in _treeSearcherFields.GetBackOfficeMediaFieldsToLoad())
                 {
                     fieldsToLoad.Add(field);
                 }
 
                 var allMediaStartNodes = currentUser != null
                     ? currentUser.CalculateMediaStartNodeIds(_entityService, _appCaches)
                     : Array.Empty<int>();
                 AppendPath(sb, UmbracoObjectTypes.Media, allMediaStartNodes, searchFrom, ignoreUserStartNodes, _entityService);
                 break;
             case UmbracoEntityTypes.Document:
                 type = "content";
                 fields.AddRange(_treeSearcherFields.GetBackOfficeDocumentFields());
                 foreach (var field in _treeSearcherFields.GetBackOfficeDocumentFieldsToLoad())
                 {
                     fieldsToLoad.Add(field);
                 }
 
                 var allContentStartNodes = currentUser != null
                     ? currentUser.CalculateContentStartNodeIds(_entityService, _appCaches)
                     : Array.Empty<int>();
                 AppendPath(sb, UmbracoObjectTypes.Document, allContentStartNodes, searchFrom, ignoreUserStartNodes, _entityService);
                 break;
             default:
                 throw new NotSupportedException("The " + typeof(BackOfficeExamineSearcher) +
                                                 " currently does not support searching against object type " +
                                                 entityType);
         }
 
+        if (contentTypeAliases?.Any() is true)
+        {
+            sb.Append($"+({string.Join(" ", contentTypeAliases.Select(alias => $"{ExamineFieldNames.ItemTypeFieldName}:{alias}"))}) ");
+        }
+
         if (!_examineManager.TryGetIndex(indexName, out IIndex? index))
         {
             throw new InvalidOperationException("No index found by name " + indexName);

src/Umbraco.Infrastructure/Examine/IBackOfficeExamineSearcher.cs

@@ -8,6 +8,7 @@
 /// </summary>
 public interface IBackOfficeExamineSearcher
 {
+    [Obsolete("Please use the method that accepts all parameters. Will be removed in V17.")]
     IEnumerable<ISearchResult> Search(
         string query,
         UmbracoEntityTypes entityType,
@@ -16,4 +17,16 @@
         out long totalFound,
         string? searchFrom = null,
         bool ignoreUserStartNodes = false);
+
+    // default implementation to avoid breaking changes falls back to old behaviour
+    IEnumerable<ISearchResult> Search(
+        string query,
+        UmbracoEntityTypes entityType,
+        int pageSize,
+        long pageIndex,
+        out long totalFound,
+        string[]? contentTypeAliases = null,
+        string? searchFrom = null,
+        bool ignoreUserStartNodes = false)
+        => Search(query, entityType, pageSize, pageIndex, out totalFound, null, searchFrom, ignoreUserStartNodes);
 }

src/Umbraco.Infrastructure/Services/Implement/IndexedEntitySearchService.cs

@@ -1,5 +1,7 @@
 using Examine;
+using Microsoft.Extensions.DependencyInjection;
 using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.DependencyInjection;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.ContentEditing;
 using Umbraco.Cms.Core.Models.Entities;
@@ -12,11 +14,32 @@
 {
     private readonly IBackOfficeExamineSearcher _backOfficeExamineSearcher;
     private readonly IEntityService _entityService;
+    private readonly IContentTypeService _contentTypeService;
+    private readonly IMediaTypeService _mediaTypeService;
+    private readonly IMemberTypeService _memberTypeService;
 
     public IndexedEntitySearchService(IBackOfficeExamineSearcher backOfficeExamineSearcher, IEntityService entityService)
+        : this(
+            backOfficeExamineSearcher,
+            entityService,
+            StaticServiceProvider.Instance.GetRequiredService<IContentTypeService>(),
+            StaticServiceProvider.Instance.GetRequiredService<IMediaTypeService>(),
+            StaticServiceProvider.Instance.GetRequiredService<IMemberTypeService>())
+    {
+    }
+
+    public IndexedEntitySearchService(
+        IBackOfficeExamineSearcher backOfficeExamineSearcher,
+        IEntityService entityService,
+        IContentTypeService contentTypeService,
+        IMediaTypeService mediaTypeService,
+        IMemberTypeService memberTypeService)
     {
         _backOfficeExamineSearcher = backOfficeExamineSearcher;
         _entityService = entityService;
+        _contentTypeService = contentTypeService;
+        _mediaTypeService = mediaTypeService;
+        _memberTypeService = memberTypeService;
     }
 
     public PagedModel<IEntitySlim> Search(UmbracoObjectTypes objectType, string query, int skip = 0, int take = 100, bool ignoreUserStartNodes = false)
@@ -29,23 +52,45 @@
         int skip = 0,
         int take = 100,
         bool ignoreUserStartNodes = false)
+        => Search(objectType, query, parentId, null, skip, take, ignoreUserStartNodes);
+
+    public PagedModel<IEntitySlim> Search(
+        UmbracoObjectTypes objectType,
+        string query,
+        Guid? parentId,
+        IEnumerable<Guid>? contentTypeIds,
+        int skip = 0,
+        int take = 100,
+        bool ignoreUserStartNodes = false)
     {
         UmbracoEntityTypes entityType = objectType switch
         {
             UmbracoObjectTypes.Document => UmbracoEntityTypes.Document,
             UmbracoObjectTypes.Media => UmbracoEntityTypes.Media,
             UmbracoObjectTypes.Member => UmbracoEntityTypes.Member,
             _ => throw new NotSupportedException("This service only supports searching for documents, media and members")
         };
 
         PaginationHelper.ConvertSkipTakeToPaging(skip, take, out var pageNumber, out var pageSize);
 
+        Guid[]? contentTypeIdsAsArray = contentTypeIds as Guid[] ?? contentTypeIds?.ToArray();
+        var contentTypeAliases = contentTypeIdsAsArray?.Length > 0
+            ? (entityType switch
+            {
+                UmbracoEntityTypes.Document => _contentTypeService.GetMany(contentTypeIdsAsArray).Select(x => x.Alias),
+                UmbracoEntityTypes.Media => _mediaTypeService.GetMany(contentTypeIdsAsArray).Select(x => x.Alias),
+                UmbracoEntityTypes.Member => _memberTypeService.GetMany(contentTypeIdsAsArray).Select(x => x.Alias),
+                _ => throw new NotSupportedException("This service only supports searching for documents, media and members")
+            }).ToArray()
+            : null;
+
         IEnumerable<ISearchResult> searchResults = _backOfficeExamineSearcher.Search(
             query,
             entityType,
             pageSize,
             pageNumber,
             out var totalFound,
+            contentTypeAliases,
             ignoreUserStartNodes: ignoreUserStartNodes,
             searchFrom: parentId?.ToString());
 

src/Umbraco.Web.UI.Client/src/external/backend-api/src/sdk.gen.ts

@@ -1,4 +1,4 @@
 // This file is auto-generated by @hey-api/openapi-ts
 
 import type { CancelablePromise } from './core/CancelablePromise';
 import { OpenAPI } from './core/OpenAPI';
@@ -1494,6 +1494,7 @@
      * @param data.skip
      * @param data.take
      * @param data.parentId
+     * @param data.allowedDocumentTypes
      * @returns unknown OK
      * @throws ApiError
      */
@@ -1505,7 +1506,8 @@
                 query: data.query,
                 skip: data.skip,
                 take: data.take,
-                parentId: data.parentId
+                parentId: data.parentId,
+                allowedDocumentTypes: data.allowedDocumentTypes
             },
             errors: {
                 401: 'The resource is protected and requires an authentication token'
@@ -3497,6 +3499,7 @@
      * @param data.skip
      * @param data.take
      * @param data.parentId
+     * @param data.allowedMediaTypes
      * @returns unknown OK
      * @throws ApiError
      */
@@ -3508,7 +3511,8 @@
                 query: data.query,
                 skip: data.skip,
                 take: data.take,
-                parentId: data.parentId
+                parentId: data.parentId,
+                allowedMediaTypes: data.allowedMediaTypes
             },
             errors: {
                 401: 'The resource is protected and requires an authentication token'
@@ -4703,6 +4707,7 @@
      * @param data.query
      * @param data.skip
      * @param data.take
+     * @param data.allowedMemberTypes
      * @returns unknown OK
      * @throws ApiError
      */
@@ -4713,7 +4718,8 @@
             query: {
                 query: data.query,
                 skip: data.skip,
-                take: data.take
+                take: data.take,
+                allowedMemberTypes: data.allowedMemberTypes
             },
             errors: {
                 401: 'The resource is protected and requires an authentication token'

src/Umbraco.Web.UI.Client/src/external/backend-api/src/types.gen.ts

@@ -3316,6 +3316,7 @@ export type GetItemDocumentData = {
 export type GetItemDocumentResponse = (Array<(DocumentItemResponseModel)>);
 
 export type GetItemDocumentSearchData = {
+    allowedDocumentTypes?: Array<(string)>;
     parentId?: string;
     query?: string;
     skip?: number;
@@ -3884,6 +3885,7 @@ export type GetItemMediaData = {
 export type GetItemMediaResponse = (Array<(MediaItemResponseModel)>);
 
 export type GetItemMediaSearchData = {
+    allowedMediaTypes?: Array<(string)>;
     parentId?: string;
     query?: string;
     skip?: number;
@@ -4235,6 +4237,7 @@ export type GetItemMemberData = {
 export type GetItemMemberResponse = (Array<(MemberItemResponseModel)>);
 
 export type GetItemMemberSearchData = {
+    allowedMemberTypes?: Array<(string)>;
     query?: string;
     skip?: number;
     take?: number;