Entity search - take one

src/Umbraco.Cms.Api.Management/Controllers/DataType/Item/SearchDataTypeItemController.cs

@@ -0,0 +1,46 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.ViewModels.DataType.Item;
+using Umbraco.Cms.Core.Mapping;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.Entities;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DataType.Item;
+
+[ApiVersion("1.0")]
+public class SearchDataTypeItemController : DatatypeItemControllerBase
+{
+    private readonly IEntitySearchService _entitySearchService;
+    private readonly IDataTypeService _dataTypeService;
+    private readonly IUmbracoMapper _mapper;
+
+    public SearchDataTypeItemController(IEntitySearchService entitySearchService, IDataTypeService dataTypeService, IUmbracoMapper mapper)
+    {
+        _entitySearchService = entitySearchService;
+        _dataTypeService = dataTypeService;
+        _mapper = mapper;
+    }
+
+    [HttpGet("search")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(PagedModel<DataTypeItemResponseModel>), StatusCodes.Status200OK)]
+    public async Task<ActionResult> Search(string query, int skip = 0, int take = 100)
+    {
+        PagedModel<IEntitySlim> searchResult = _entitySearchService.Search(UmbracoObjectTypes.DataType, query, skip, take);
+        if (searchResult.Items.Any() is false)
+        {
+            return Ok(new PagedModel<DataTypeItemResponseModel> { Total = searchResult.Total });
+        }
+
+        IEnumerable<IDataType> dataTypes = await _dataTypeService.GetAllAsync(searchResult.Items.Select(item => item.Key).ToArray());
+        var result = new PagedModel<DataTypeItemResponseModel>
+        {
+            Items = _mapper.MapEnumerable<IDataType, DataTypeItemResponseModel>(dataTypes),
+            Total = searchResult.Total
+        };
+
+        return Ok(result);
+    }
+}

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

@@ -0,0 +1,39 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.ViewModels.Document.Item;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.Entities;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document.Item;
+
+[ApiVersion("1.0")]
+public class SearchDocumentItemController : DocumentItemControllerBase
+{
+    private readonly IEntitySearchService _entitySearchService;
+    private readonly IDocumentPresentationFactory _documentPresentationFactory;
+
+    public SearchDocumentItemController(IEntitySearchService entitySearchService, IDocumentPresentationFactory documentPresentationFactory)
+    {
+        _entitySearchService = entitySearchService;
+        _documentPresentationFactory = documentPresentationFactory;
+    }
+
+    [HttpGet("search")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(PagedModel<DocumentItemResponseModel>), StatusCodes.Status200OK)]
+    public async Task<ActionResult> Search(string query, int skip = 0, int take = 100)
+    {
+        // FIXME: use Examine and handle user start nodes
+        PagedModel<IEntitySlim> searchResult = _entitySearchService.Search(UmbracoObjectTypes.Document, query, skip, take);
+        var result = new PagedModel<DocumentItemResponseModel>
+        {
+            Items = searchResult.Items.OfType<IDocumentEntitySlim>().Select(_documentPresentationFactory.CreateItemResponseModel),
+            Total = searchResult.Total
+        };
+
+        return await Task.FromResult(Ok(result));
+    }
+}

src/Umbraco.Cms.Api.Management/Controllers/DocumentType/Item/SearchDocumentTypeItemController.cs

@@ -0,0 +1,47 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.ViewModels.DocumentType.Item;
+using Umbraco.Cms.Core.Mapping;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.Entities;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DocumentType.Item;
+
+[ApiVersion("1.0")]
+public class SearchDocumentTypeItemController : DocumentTypeItemControllerBase
+{
+    private readonly IEntitySearchService _entitySearchService;
+    private readonly IContentTypeService _contentTypeService;
+    private readonly IUmbracoMapper _mapper;
+
+    public SearchDocumentTypeItemController(IEntitySearchService entitySearchService, IContentTypeService contentTypeService, IUmbracoMapper mapper)
+    {
+        _entitySearchService = entitySearchService;
+        _contentTypeService = contentTypeService;
+        _mapper = mapper;
+    }
+
+    [HttpGet("search")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(PagedModel<DocumentTypeItemResponseModel>), StatusCodes.Status200OK)]
+    public async Task<ActionResult> Search(string query, int skip = 0, int take = 100)
+    {
+        PagedModel<IEntitySlim> searchResult = _entitySearchService.Search(UmbracoObjectTypes.DocumentType, query, skip, take);
+        if (searchResult.Items.Any() is false)
+        {
+            return await Task.FromResult(Ok(new PagedModel<DocumentTypeItemResponseModel> { Total = searchResult.Total }));
+        }
+
+        IEnumerable<IContentType> contentTypes = _contentTypeService.GetAll(searchResult.Items.Select(item => item.Key).ToArray().EmptyNull());
+        var result = new PagedModel<DocumentTypeItemResponseModel>
+        {
+            Items = _mapper.MapEnumerable<IContentType, DocumentTypeItemResponseModel>(contentTypes),
+            Total = searchResult.Total
+        };
+
+        return Ok(result);
+    }
+}

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

@@ -0,0 +1,39 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.ViewModels.Media.Item;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.Entities;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Media.Item;
+
+[ApiVersion("1.0")]
+public class SearchMediaItemController : MediaItemControllerBase
+{
+    private readonly IEntitySearchService _entitySearchService;
+    private readonly IMediaPresentationFactory _mediaPresentationFactory;
+
+    public SearchMediaItemController(IEntitySearchService entitySearchService, IMediaPresentationFactory mediaPresentationFactory)
+    {
+        _entitySearchService = entitySearchService;
+        _mediaPresentationFactory = mediaPresentationFactory;
+    }
+
+    [HttpGet("search")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(PagedModel<MediaItemResponseModel>), StatusCodes.Status200OK)]
+    public async Task<ActionResult> Search(string query, int skip = 0, int take = 100)
+    {
+        // FIXME: use Examine and handle user start nodes
+        PagedModel<IEntitySlim> searchResult = _entitySearchService.Search(UmbracoObjectTypes.Media, query, skip, take);
+        var result = new PagedModel<MediaItemResponseModel>
+        {
+            Items = searchResult.Items.OfType<IMediaEntitySlim>().Select(_mediaPresentationFactory.CreateItemResponseModel),
+            Total = searchResult.Total
+        };
+
+        return await Task.FromResult(Ok(result));
+    }
+}

src/Umbraco.Cms.Api.Management/Controllers/MediaType/Item/SearchMediaTypeItemController.cs

@@ -0,0 +1,47 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.ViewModels.MediaType.Item;
+using Umbraco.Cms.Core.Mapping;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.Entities;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.MediaType.Item;
+
+[ApiVersion("1.0")]
+public class SearchMediaTypeItemController : MediaTypeItemControllerBase
+{
+    private readonly IEntitySearchService _entitySearchService;
+    private readonly IMediaTypeService _mediaTypeService;
+    private readonly IUmbracoMapper _mapper;
+
+    public SearchMediaTypeItemController(IEntitySearchService entitySearchService, IMediaTypeService mediaTypeService, IUmbracoMapper mapper)
+    {
+        _entitySearchService = entitySearchService;
+        _mediaTypeService = mediaTypeService;
+        _mapper = mapper;
+    }
+
+    [HttpGet("search")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(PagedModel<MediaTypeItemResponseModel>), StatusCodes.Status200OK)]
+    public async Task<ActionResult> Search(string query, int skip = 0, int take = 100)
+    {
+        PagedModel<IEntitySlim> searchResult = _entitySearchService.Search(UmbracoObjectTypes.MediaType, query, skip, take);
+        if (searchResult.Items.Any() is false)
+        {
+            return await Task.FromResult(Ok(new PagedModel<MediaTypeItemResponseModel> { Total = searchResult.Total }));
+        }
+
+        IEnumerable<IMediaType> mediaTypes = _mediaTypeService.GetAll(searchResult.Items.Select(item => item.Key).ToArray().EmptyNull());
+        var result = new PagedModel<MediaTypeItemResponseModel>
+        {
+            Items = _mapper.MapEnumerable<IMediaType, MediaTypeItemResponseModel>(mediaTypes),
+            Total = searchResult.Total
+        };
+
+        return Ok(result);
+    }
+}

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

@@ -0,0 +1,39 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.ViewModels.Member.Item;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.Entities;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Member.Item;
+
+[ApiVersion("1.0")]
+public class SearchMemberItemController : MemberItemControllerBase
+{
+    private readonly IEntitySearchService _entitySearchService;
+    private readonly IMemberPresentationFactory _memberPresentationFactory;
+
+    public SearchMemberItemController(IEntitySearchService entitySearchService, IMemberPresentationFactory memberPresentationFactory)
+    {
+        _entitySearchService = entitySearchService;
+        _memberPresentationFactory = memberPresentationFactory;
+    }
+
+    [HttpGet("search")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(PagedModel<MemberItemResponseModel>), StatusCodes.Status200OK)]
+    public async Task<ActionResult> Search(string query, int skip = 0, int take = 100)
+    {
+        // FIXME: use Examine
+        PagedModel<IEntitySlim> searchResult = _entitySearchService.Search(UmbracoObjectTypes.Member, query, skip, take);
+        var result = new PagedModel<MemberItemResponseModel>
+        {
+            Items = searchResult.Items.OfType<IMemberEntitySlim>().Select(_memberPresentationFactory.CreateItemResponseModel),
+            Total = searchResult.Total
+        };
+
+        return await Task.FromResult(Ok(result));
+    }
+}

src/Umbraco.Cms.Api.Management/Controllers/MemberType/Item/SearchMemberTypeItemController.cs

@@ -0,0 +1,46 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.ViewModels.MemberType.Item;
+using Umbraco.Cms.Core.Mapping;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.Entities;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Api.Management.Controllers.MemberType.Item;
+
+[ApiVersion("1.0")]
+public class SearchMemberTypeItemController : MemberTypeItemControllerBase
+{
+    private readonly IEntitySearchService _entitySearchService;
+    private readonly IMemberTypeService _memberTypeService;
+    private readonly IUmbracoMapper _mapper;
+
+    public SearchMemberTypeItemController(IEntitySearchService entitySearchService, IMemberTypeService memberTypeService, IUmbracoMapper mapper)
+    {
+        _entitySearchService = entitySearchService;
+        _memberTypeService = memberTypeService;
+        _mapper = mapper;
+    }
+
+    [HttpGet("search")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(PagedModel<MemberTypeItemResponseModel>), StatusCodes.Status200OK)]
+    public async Task<ActionResult> Search(string query, int skip = 0, int take = 100)
+    {
+        PagedModel<IEntitySlim> searchResult = _entitySearchService.Search(UmbracoObjectTypes.MemberType, query, skip, take);
+        if (searchResult.Items.Any() is false)
+        {
+            return await Task.FromResult(Ok(new PagedModel<MemberTypeItemResponseModel> { Total = searchResult.Total }));
+        }
+
+        IEnumerable<IMemberType> memberTypes = _memberTypeService.GetAll(searchResult.Items.Select(item => item.Key).ToArray());
+        var result = new PagedModel<MemberTypeItemResponseModel>
+        {
+            Items = _mapper.MapEnumerable<IMemberType, MemberTypeItemResponseModel>(memberTypes),
+            Total = searchResult.Total
+        };
+
+        return Ok(result);
+    }
+}

src/Umbraco.Cms.Api.Management/Controllers/Template/Item/SearchTemplateItemController.cs

@@ -0,0 +1,46 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.ViewModels.Template.Item;
+using Umbraco.Cms.Core.Mapping;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.Entities;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Template.Item;
+
+[ApiVersion("1.0")]
+public class SearchTemplateItemController : TemplateItemControllerBase
+{
+    private readonly IEntitySearchService _entitySearchService;
+    private readonly ITemplateService _templateService;
+    private readonly IUmbracoMapper _mapper;
+
+    public SearchTemplateItemController(IEntitySearchService entitySearchService, ITemplateService templateService, IUmbracoMapper mapper)
+    {
+        _entitySearchService = entitySearchService;
+        _templateService = templateService;
+        _mapper = mapper;
+    }
+
+    [HttpGet("search")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(PagedModel<TemplateItemResponseModel>), StatusCodes.Status200OK)]
+    public async Task<ActionResult> Search(string query, int skip = 0, int take = 100)
+    {
+        PagedModel<IEntitySlim> searchResult = _entitySearchService.Search(UmbracoObjectTypes.Template, query, skip, take);
+        if (searchResult.Items.Any() is false)
+        {
+            return Ok(new PagedModel<TemplateItemResponseModel> { Total = searchResult.Total });
+        }
+
+        IEnumerable<ITemplate> templates = await _templateService.GetAllAsync(searchResult.Items.Select(item => item.Key).ToArray());
+        var result = new PagedModel<TemplateItemResponseModel>
+        {
+            Items = _mapper.MapEnumerable<ITemplate, TemplateItemResponseModel>(templates),
+            Total = searchResult.Total
+        };
+
+        return Ok(result);
+    }
+}