Implemented content search. (#32)

backend/src/Logitar.Cms.Contracts/Contents/ContentSort.cs

@@ -0,0 +1,7 @@
+namespace Logitar.Cms.Contracts.Contents;
+
+public enum ContentSort
+{
+  UniqueName,
+  UpdatedOn
+}

backend/src/Logitar.Cms.Contracts/Contents/ContentSortOption.cs

@@ -0,0 +1,20 @@
+using Logitar.Cms.Contracts.Search;
+
+namespace Logitar.Cms.Contracts.Contents;
+
+public record ContentSortOption : SortOption
+{
+  public new ContentSort Field
+  {
+    get => Enum.Parse<ContentSort>(base.Field);
+    set => base.Field = value.ToString();
+  }
+
+  public ContentSortOption() : this(ContentSort.UpdatedOn, isDescending: true)
+  {
+  }
+
+  public ContentSortOption(ContentSort field, bool isDescending = false) : base(field.ToString(), isDescending)
+  {
+  }
+}

backend/src/Logitar.Cms.Contracts/Contents/SearchContentsPayload.cs

@@ -0,0 +1,11 @@
+using Logitar.Cms.Contracts.Search;
+
+namespace Logitar.Cms.Contracts.Contents;
+
+public record SearchContentsPayload : SearchPayload
+{
+  public Guid? ContentTypeId { get; set; }
+  public Guid? LanguageId { get; set; }
+
+  public new List<ContentSortOption>? Sort { get; set; }
+}

backend/src/Logitar.Cms.Core/ContentTypes/Queries/SearchContentTypesQueryHandler.cs

@@ -6,15 +6,15 @@ namespace Logitar.Cms.Core.ContentTypes.Queries;
 
 internal class SearchContentTypesQueryHandler : IRequestHandler<SearchContentTypesQuery, SearchResults<CmsContentType>>
 {
-  private readonly IContentTypeQuerier _fieldTypeQuerier;
+  private readonly IContentTypeQuerier _contentTypeQuerier;
 
   public SearchContentTypesQueryHandler(IContentTypeQuerier fieldTypeQuerier)
   {
-    _fieldTypeQuerier = fieldTypeQuerier;
+    _contentTypeQuerier = fieldTypeQuerier;
   }
 
   public async Task<SearchResults<CmsContentType>> Handle(SearchContentTypesQuery query, CancellationToken cancellationToken)
   {
-    return await _fieldTypeQuerier.SearchAsync(query.Payload, cancellationToken);
+    return await _contentTypeQuerier.SearchAsync(query.Payload, cancellationToken);
   }
 }

backend/src/Logitar.Cms.Core/Contents/IContentQuerier.cs

@@ -1,4 +1,5 @@
 using Logitar.Cms.Contracts.Contents;
+using Logitar.Cms.Contracts.Search;
 
 namespace Logitar.Cms.Core.Contents;
 
@@ -7,4 +8,6 @@ public interface IContentQuerier
   Task<ContentItem> ReadAsync(ContentAggregate content, CancellationToken cancellationToken = default);
   Task<ContentItem?> ReadAsync(ContentId id, CancellationToken cancellationToken = default);
   Task<ContentItem?> ReadAsync(Guid id, CancellationToken cancellationToken = default);
+
+  Task<SearchResults<ContentLocale>> SearchAsync(SearchContentsPayload payload, CancellationToken cancellationToken = default);
 }

backend/src/Logitar.Cms.Core/Contents/IContentRepository.cs

@@ -6,6 +6,7 @@ namespace Logitar.Cms.Core.Contents;
 
 public interface IContentRepository
 {
+  Task<IReadOnlyCollection<ContentAggregate>> LoadAsync(CancellationToken cancellationToken = default);
   Task<ContentAggregate?> LoadAsync(ContentId id, CancellationToken cancellationToken = default);
   Task<ContentAggregate?> LoadAsync(ContentTypeId contentTypeId, LanguageId? languageId, UniqueNameUnit uniqueName, CancellationToken cancellationToken = default);
 

backend/src/Logitar.Cms.Core/Contents/Queries/SearchContentsQuery.cs

@@ -0,0 +1,7 @@
+using Logitar.Cms.Contracts.Contents;
+using Logitar.Cms.Contracts.Search;
+using MediatR;
+
+namespace Logitar.Cms.Core.Contents.Queries;
+
+public record SearchContentsQuery(SearchContentsPayload Payload) : IRequest<SearchResults<ContentLocale>>;

backend/src/Logitar.Cms.Core/Contents/Queries/SearchContentsQueryHandler.cs

@@ -0,0 +1,20 @@
+using Logitar.Cms.Contracts.Contents;
+using Logitar.Cms.Contracts.Search;
+using MediatR;
+
+namespace Logitar.Cms.Core.Contents.Queries;
+
+internal class SearchContentsQueryHandler : IRequestHandler<SearchContentsQuery, SearchResults<ContentLocale>>
+{
+  private readonly IContentQuerier _contentQuerier;
+
+  public SearchContentsQueryHandler(IContentQuerier fieldTypeQuerier)
+  {
+    _contentQuerier = fieldTypeQuerier;
+  }
+
+  public async Task<SearchResults<ContentLocale>> Handle(SearchContentsQuery query, CancellationToken cancellationToken)
+  {
+    return await _contentQuerier.SearchAsync(query.Payload, cancellationToken);
+  }
+}

backend/src/Logitar.Cms.EntityFrameworkCore/Entities/ContentItemEntity.cs

@@ -28,7 +28,8 @@ private ContentItemEntity() : base()
   {
   }
 
-  public override IEnumerable<ActorId> GetActorIds()
+  public override IEnumerable<ActorId> GetActorIds() => GetActorIds(includeLocales: true);
+  public IEnumerable<ActorId> GetActorIds(bool includeLocales)
   {
     List<ActorId> actorIds = base.GetActorIds().ToList();
 
@@ -37,9 +38,12 @@ public override IEnumerable<ActorId> GetActorIds()
       actorIds.AddRange(ContentType.GetActorIds());
     }
 
-    foreach (ContentLocaleEntity locale in Locales)
+    if (includeLocales)
     {
-      actorIds.AddRange(locale.GetActorIds());
+      foreach (ContentLocaleEntity locale in Locales)
+      {
+        actorIds.AddRange(locale.GetActorIds(includeItem: false));
+      }
     }
 
     return actorIds.AsReadOnly();

backend/src/Logitar.Cms.EntityFrameworkCore/Entities/ContentLocaleEntity.cs

@@ -76,7 +76,22 @@ private ContentLocaleEntity()
   {
   }
 
-  public IEnumerable<ActorId> GetActorIds() => [new(CreatedBy), new(UpdatedBy)];
+  public IEnumerable<ActorId> GetActorIds(bool includeItem)
+  {
+    List<ActorId> actorIds = [new(CreatedBy), new(UpdatedBy)];
+
+    if (Language != null)
+    {
+      actorIds.AddRange(Language.GetActorIds());
+    }
+
+    if (includeItem && Item != null)
+    {
+      actorIds.AddRange(Item.GetActorIds(includeLocales: false));
+    }
+
+    return actorIds.AsReadOnly();
+  }
 
   public void Update(ContentLocaleUnit locale, DomainEvent @event)
   {

backend/src/Logitar.Cms.EntityFrameworkCore/Mapper.cs

@@ -112,6 +112,19 @@ public ContentItem ToContentItem(ContentItemEntity source)
 
     return destination;
   }
+
+  public ContentLocale ToContentLocale(ContentLocaleEntity source)
+  {
+    if (source.Item == null)
+    {
+      throw new ArgumentException($"The {nameof(source.Item)} is required.", nameof(source));
+    }
+
+    ContentItem item = ToContentItem(source.Item);
+
+    return item.Locales.SingleOrDefault() ?? item.Invariant;
+  }
+
   private ContentLocale ToContentLocale(ContentLocaleEntity source, ContentItem item)
   {
     if (source.LanguageId != null && source.Language == null)

backend/src/Logitar.Cms.EntityFrameworkCore/Queriers/ContentQuerier.cs

@@ -1,9 +1,12 @@
 using Logitar.Cms.Contracts.Actors;
 using Logitar.Cms.Contracts.Contents;
+using Logitar.Cms.Contracts.Search;
 using Logitar.Cms.Core.Contents;
 using Logitar.Cms.EntityFrameworkCore.Actors;
 using Logitar.Cms.EntityFrameworkCore.Entities;
+using Logitar.Data;
 using Logitar.EventSourcing;
+using Logitar.Identity.EntityFrameworkCore.Relational;
 using Microsoft.EntityFrameworkCore;
 
 namespace Logitar.Cms.EntityFrameworkCore.Queriers;
@@ -12,11 +15,17 @@ internal class ContentQuerier : IContentQuerier
 {
   private readonly IActorService _actorService;
   private readonly DbSet<ContentItemEntity> _contentItems;
+  private readonly DbSet<ContentLocaleEntity> _contentLocales;
+  private readonly ISearchHelper _searchHelper;
+  private readonly ISqlHelper _sqlHelper;
 
-  public ContentQuerier(IActorService actorService, CmsContext context)
+  public ContentQuerier(IActorService actorService, CmsContext context, ISearchHelper searchHelper, ISqlHelper sqlHelper)
   {
     _actorService = actorService;
     _contentItems = context.ContentItems;
+    _contentLocales = context.ContentLocales;
+    _searchHelper = searchHelper;
+    _sqlHelper = sqlHelper;
   }
 
   public async Task<ContentItem> ReadAsync(ContentAggregate content, CancellationToken cancellationToken)
@@ -38,6 +47,59 @@ public async Task<ContentItem> ReadAsync(ContentAggregate content, CancellationT
     return content == null ? null : await MapAsync(content, cancellationToken);
   }
 
+  public async Task<SearchResults<ContentLocale>> SearchAsync(SearchContentsPayload payload, CancellationToken cancellationToken)
+  {
+    IQueryBuilder builder = _sqlHelper.QueryFrom(CmsDb.ContentLocales.Table).SelectAll(CmsDb.ContentLocales.Table)
+      .Join(CmsDb.ContentItems.ContentItemId, CmsDb.ContentLocales.ContentItemId)
+      .Join(CmsDb.ContentTypes.ContentTypeId, CmsDb.ContentItems.ContentTypeId)
+      .LeftJoin(CmsDb.Languages.LanguageId, CmsDb.ContentLocales.LanguageId)
+      .ApplyIdInFilter(CmsDb.ContentItems.UniqueId, payload);
+    _searchHelper.ApplyTextSearch(builder, payload.Search, CmsDb.ContentLocales.UniqueName);
+
+    if (payload.ContentTypeId.HasValue)
+    {
+      builder.Where(CmsDb.ContentTypes.UniqueId, Operators.IsEqualTo(payload.ContentTypeId.Value.ToString()));
+    }
+
+    ConditionalOperator @operator = payload.LanguageId.HasValue ? Operators.IsEqualTo(payload.LanguageId.Value.ToString()) : Operators.IsNull();
+    builder.Where(CmsDb.Languages.UniqueId, @operator);
+
+    IQueryable<ContentLocaleEntity> query = _contentLocales.FromQuery(builder).AsNoTracking()
+      .Include(x => x.Item).ThenInclude(x => x!.ContentType)
+      .Include(x => x.Language);
+
+    long total = await query.LongCountAsync(cancellationToken);
+
+    IOrderedQueryable<ContentLocaleEntity>? ordered = null;
+    if (payload.Sort != null)
+    {
+      foreach (ContentSortOption sort in payload.Sort)
+      {
+        switch (sort.Field)
+        {
+          case ContentSort.UniqueName:
+            ordered = (ordered == null)
+              ? (sort.IsDescending ? query.OrderByDescending(x => x.UniqueName) : query.OrderBy(x => x.UniqueName))
+              : (sort.IsDescending ? ordered.ThenByDescending(x => x.UniqueName) : ordered.ThenBy(x => x.UniqueName));
+            break;
+          case ContentSort.UpdatedOn:
+            ordered = (ordered == null)
+              ? (sort.IsDescending ? query.OrderByDescending(x => x.UpdatedOn) : query.OrderBy(x => x.UpdatedOn))
+              : (sort.IsDescending ? ordered.ThenByDescending(x => x.UpdatedOn) : ordered.ThenBy(x => x.UpdatedOn));
+            break;
+        }
+      }
+    }
+    query = ordered ?? query;
+
+    query = query.ApplyPaging(payload);
+
+    ContentLocaleEntity[] locales = await query.ToArrayAsync(cancellationToken);
+    IEnumerable<ContentLocale> items = await MapAsync(locales, cancellationToken);
+
+    return new SearchResults<ContentLocale>(items, total);
+  }
+
   private async Task<ContentItem> MapAsync(ContentItemEntity content, CancellationToken cancellationToken)
     => (await MapAsync([content], cancellationToken)).Single();
   private async Task<IReadOnlyCollection<ContentItem>> MapAsync(IEnumerable<ContentItemEntity> contents, CancellationToken cancellationToken)
@@ -48,4 +110,15 @@ private async Task<IReadOnlyCollection<ContentItem>> MapAsync(IEnumerable<Conten
 
     return contents.Select(mapper.ToContentItem).ToArray();
   }
+
+  private async Task<ContentLocale> MapAsync(ContentLocaleEntity locale, CancellationToken cancellationToken)
+    => (await MapAsync([locale], cancellationToken)).Single();
+  private async Task<IReadOnlyCollection<ContentLocale>> MapAsync(IEnumerable<ContentLocaleEntity> locales, CancellationToken cancellationToken)
+  {
+    IEnumerable<ActorId> actorIds = locales.SelectMany(locales => locales.GetActorIds(includeItem: true));
+    IReadOnlyCollection<Actor> actors = await _actorService.FindAsync(actorIds, cancellationToken);
+    Mapper mapper = new(actors);
+
+    return locales.Select(mapper.ToContentLocale).ToArray();
+  }
 }

backend/src/Logitar.Cms.EntityFrameworkCore/Queriers/ContentTypeQuerier.cs

@@ -99,8 +99,8 @@ public async Task<SearchResults<CmsContentType>> SearchAsync(SearchContentTypesP
 
     query = query.ApplyPaging(payload);
 
-    ContentTypeEntity[] fieldTypes = await query.ToArrayAsync(cancellationToken);
-    IEnumerable<CmsContentType> items = await MapAsync(fieldTypes, cancellationToken);
+    ContentTypeEntity[] contentTypes = await query.ToArrayAsync(cancellationToken);
+    IEnumerable<CmsContentType> items = await MapAsync(contentTypes, cancellationToken);
 
     return new SearchResults<CmsContentType>(items, total);
   }

backend/src/Logitar.Cms.EntityFrameworkCore/Repositories/ContentRepository.cs

@@ -22,6 +22,11 @@ public ContentRepository(IEventBus eventBus, EventContext eventContext, IEventSe
     _sqlHelper = sqlHelper;
   }
 
+  public async Task<IReadOnlyCollection<ContentAggregate>> LoadAsync(CancellationToken cancellationToken)
+  {
+    return (await base.LoadAsync<ContentAggregate>(cancellationToken)).ToArray();
+  }
+
   public async Task<ContentAggregate?> LoadAsync(ContentId id, CancellationToken cancellationToken)
   {
     return await base.LoadAsync<ContentAggregate>(id.AggregateId, cancellationToken);

backend/src/Logitar.Cms.Web/Controllers/ContentController.cs

@@ -1,7 +1,9 @@
 using Logitar.Cms.Contracts.Contents;
+using Logitar.Cms.Contracts.Search;
 using Logitar.Cms.Core;
 using Logitar.Cms.Core.Contents.Commands;
 using Logitar.Cms.Core.Contents.Queries;
+using Logitar.Cms.Web.Models.Contents;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 
@@ -48,4 +50,11 @@ public async Task<ActionResult<ContentItem>> SaveLocaleAsync(Guid contentId, Gui
     ContentItem? content = await _pipeline.ExecuteAsync(new SaveContentLocaleCommand(contentId, languageId, payload), cancellationToken);
     return content == null ? NotFound() : Ok(content);
   }
+
+  [HttpGet]
+  public async Task<ActionResult<SearchResults<ContentLocale>>> SearchAsync([FromQuery] SearchContentsParameters parameters, CancellationToken cancellationToken)
+  {
+    SearchResults<ContentLocale> contents = await _pipeline.ExecuteAsync(new SearchContentsQuery(parameters.ToPayload()), cancellationToken);
+    return Ok(contents);
+  }
 }

backend/src/Logitar.Cms.Web/Models/Contents/SearchContentsParameters.cs

@@ -0,0 +1,41 @@
+using Logitar.Cms.Contracts.Contents;
+using Logitar.Cms.Contracts.Search;
+using Logitar.Cms.Web.Models.Search;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Logitar.Cms.Web.Models.Contents;
+
+public record SearchContentsParameters : SearchParameters
+{
+  [FromQuery(Name = "type")]
+  public Guid? ContentTypeId { get; set; }
+
+  [FromQuery(Name = "language")]
+  public Guid? LanguageId { get; set; }
+
+  public SearchContentsPayload ToPayload()
+  {
+    SearchContentsPayload payload = new()
+    {
+      ContentTypeId = ContentTypeId,
+      LanguageId = LanguageId
+    };
+
+    FillPayload(payload);
+
+    var sortOptions = ((SearchPayload)payload).Sort;
+    if (sortOptions != null)
+    {
+      payload.Sort = new List<ContentSortOption>(capacity: sortOptions.Count);
+      foreach (var sort in sortOptions)
+      {
+        if (Enum.TryParse(sort.Field, out ContentSort field))
+        {
+          payload.Sort.Add(new ContentSortOption(field, sort.IsDescending));
+        }
+      }
+    }
+
+    return payload;
+  }
+}