VCST-3154: GetByOuterId in CRUD service (#2909)

Co-authored-by: Artem Dudarev <artem@virtoworks.com>

Author: Ljutyj

src/VirtoCommerce.Platform.Core/Extensions/CrudServiceExtensions.cs

@@ -28,12 +28,43 @@ public static Task<TModel> GetNoCloneAsync<TModel>(this ICrudService<TModel> cru
     public static async Task<TModel> GetByIdAsync<TModel>(this ICrudService<TModel> crudService, string id, string responseGroup = null, bool clone = true)
         where TModel : Entity
     {
-        if (id == null)
+        if (string.IsNullOrEmpty(id))
         {
             return null;
         }
 
-        var entities = await crudService.GetAsync(new[] { id }, responseGroup, clone);
+        var entities = await crudService.GetAsync([id], responseGroup, clone);
+
+        return entities?.FirstOrDefault();
+    }
+
+    /// <summary>
+    /// Returns data from the cache without cloning. This consumes less memory, but the returned data must not be modified.
+    /// </summary>
+    public static Task<IList<TModel>> GetByOuterIdsNoCloneAsync<TModel>(this IOuterEntityService<TModel> outerEntityService, IList<string> outerIds, string responseGroup = null)
+        where TModel : Entity, IHasOuterId
+    {
+        return outerEntityService.GetByOuterIdsAsync(outerIds, responseGroup, clone: false);
+    }
+
+    /// <summary>
+    /// Returns data from the cache without cloning. This consumes less memory, but the returned data must not be modified.
+    /// </summary>
+    public static Task<TModel> GetByOuterIdNoCloneAsync<TModel>(this IOuterEntityService<TModel> outerEntityService, string outerId, string responseGroup = null)
+        where TModel : Entity, IHasOuterId
+    {
+        return outerEntityService.GetByOuterIdAsync(outerId, responseGroup, clone: false);
+    }
+
+    public static async Task<TModel> GetByOuterIdAsync<TModel>(this IOuterEntityService<TModel> outerEntityService, string outerId, string responseGroup = null, bool clone = true)
+        where TModel : Entity, IHasOuterId
+    {
+        if (string.IsNullOrEmpty(outerId))
+        {
+            return null;
+        }
+
+        var entities = await outerEntityService.GetByOuterIdsAsync([outerId], responseGroup, clone);
 
         return entities?.FirstOrDefault();
     }

src/VirtoCommerce.Platform.Core/GenericCrud/IOuterEntityService.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using VirtoCommerce.Platform.Core.Common;
+
+namespace VirtoCommerce.Platform.Core.GenericCrud;
+
+/// <summary>
+/// Generic interface for outer entities to use with CRUD services.
+/// </summary>
+/// <typeparam name="T"></typeparam>
+public interface IOuterEntityService<T> : ICrudService<T>
+    where T : Entity, IHasOuterId
+{
+    /// <summary>
+    /// Returns a list of model instances for specified outer IDs (integration key)
+    /// </summary>
+    /// <param name="outerIds">List of outer IDs</param>
+    /// <param name="responseGroup"></param>
+    /// <param name="clone">If false, returns data from the cache without cloning. This consumes less memory, but the returned data must not be modified.</param>
+    /// <returns></returns>
+    Task<IList<T>> GetByOuterIdsAsync(IList<string> outerIds, string responseGroup = null, bool clone = true);
+}

src/VirtoCommerce.Platform.Data/GenericCrud/CrudService.cs

@@ -21,12 +21,12 @@ namespace VirtoCommerce.Platform.Data.GenericCrud
     /// </summary>
     /// <typeparam name="TModel">The type of service layer model</typeparam>
     /// <typeparam name="TEntity">The type of data access layer entity (EF) </typeparam>
-    /// <typeparam name="TChangeEvent">The type of *change event</typeparam>
+    /// <typeparam name="TChangingEvent">The type of *changing event</typeparam>
     /// <typeparam name="TChangedEvent">The type of *changed event</typeparam>
-    public abstract class CrudService<TModel, TEntity, TChangeEvent, TChangedEvent> : ICrudService<TModel>
+    public abstract class CrudService<TModel, TEntity, TChangingEvent, TChangedEvent> : ICrudService<TModel>
         where TModel : Entity, ICloneable
         where TEntity : Entity, IDataEntity<TEntity, TModel>
-        where TChangeEvent : GenericChangedEntryEvent<TModel>
+        where TChangingEvent : GenericChangedEntryEvent<TModel>
         where TChangedEvent : GenericChangedEntryEvent<TModel>
     {
         private readonly IEventPublisher _eventPublisher;
@@ -38,7 +38,7 @@ public abstract class CrudService<TModel, TEntity, TChangeEvent, TChangedEvent>
         /// </summary>
         /// <param name="repositoryFactory">Repository factory to get access to the data source</param>
         /// <param name="platformMemoryCache">The cache used to temporary store returned values</param>
-        /// <param name="eventPublisher">The publisher to propagate platform-wide events (TChangeEvent, TChangedEvent)</param>
+        /// <param name="eventPublisher">The publisher to propagate platform-wide events (TChangingEvent, TChangedEvent)</param>
         protected CrudService(Func<IRepository> repositoryFactory, IPlatformMemoryCache platformMemoryCache, IEventPublisher eventPublisher)
         {
             _repositoryFactory = repositoryFactory;
@@ -215,7 +215,7 @@ public virtual async Task SaveChangesAsync(IList<TModel> models)
                 }
 
                 // Raise domain events
-                await _eventPublisher.Publish(EventFactory<TChangeEvent>(changedEntries));
+                await _eventPublisher.Publish(EventFactory<TChangingEvent>(changedEntries));
                 await CommitAsync(repository);
             }
 
@@ -238,7 +238,7 @@ protected virtual Task<IList<TEntity>> LoadExistingEntities(IRepository reposito
         {
             var ids = models.Where(x => !x.IsTransient()).Select(x => x.Id).ToList();
 
-            return ids.Any()
+            return ids.Count > 0
                 ? LoadEntities(repository, ids)
                 : Task.FromResult<IList<TEntity>>(Array.Empty<TEntity>());
         }
@@ -263,33 +263,33 @@ public virtual async Task DeleteAsync(IList<string> ids, bool softDelete = false
         {
             var models = await GetAsync(ids);
 
-            using (var repository = _repositoryFactory())
-            {
-                // Raise domain events before deletion
-                var changedEntries = models.Select(x => new GenericChangedEntry<TModel>(x, EntryState.Deleted)).ToList();
-                await _eventPublisher.Publish(EventFactory<TChangeEvent>(changedEntries));
+            using var repository = _repositoryFactory();
 
-                if (softDelete)
-                {
-                    await SoftDelete(repository, ids);
-                    await repository.UnitOfWork.CommitAsync();
-                }
-                else
+            // Raise domain events before deletion
+            var changedEntries = models.Select(x => new GenericChangedEntry<TModel>(x, EntryState.Deleted)).ToList();
+            await _eventPublisher.Publish(EventFactory<TChangingEvent>(changedEntries));
+
+            if (softDelete)
+            {
+                await SoftDelete(repository, ids);
+                await repository.UnitOfWork.CommitAsync();
+            }
+            else
+            {
+                var keyMap = new PrimaryKeyResolvingMap();
+                foreach (var model in models)
                 {
-                    var keyMap = new PrimaryKeyResolvingMap();
-                    foreach (var model in models)
-                    {
-                        var entity = FromModel(model, keyMap);
-                        repository.Remove(entity);
-                    }
-                    await repository.UnitOfWork.CommitAsync();
-                    await AfterDeleteAsync(models, changedEntries);
+                    var entity = FromModel(model, keyMap);
+                    repository.Remove(entity);
                 }
-                ClearCache(models);
-
-                // Raise domain events after deletion
-                await _eventPublisher.Publish(EventFactory<TChangedEvent>(changedEntries));
+                await repository.UnitOfWork.CommitAsync();
+                await AfterDeleteAsync(models, changedEntries);
             }
+
+            ClearCache(models);
+
+            // Raise domain events after deletion
+            await _eventPublisher.Publish(EventFactory<TChangedEvent>(changedEntries));
         }
 
         /// <summary>
@@ -342,7 +342,7 @@ protected virtual TEntity FromModel(TModel model, PrimaryKeyResolvingMap keyMap)
 
         protected virtual GenericChangedEntryEvent<TModel> EventFactory<TEvent>(IList<GenericChangedEntry<TModel>> changedEntries)
         {
-            return (GenericChangedEntryEvent<TModel>)typeof(TEvent).GetConstructor(new[] { typeof(IEnumerable<GenericChangedEntry<TModel>>) }).Invoke(new object[] { changedEntries });
+            return (GenericChangedEntryEvent<TModel>)typeof(TEvent).GetConstructor([typeof(IEnumerable<GenericChangedEntry<TModel>>)]).Invoke([changedEntries]);
         }
     }
 }

src/VirtoCommerce.Platform.Data/GenericCrud/OuterEntityService.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+using VirtoCommerce.Platform.Core.Caching;
+using VirtoCommerce.Platform.Core.Common;
+using VirtoCommerce.Platform.Core.Domain;
+using VirtoCommerce.Platform.Core.Events;
+using VirtoCommerce.Platform.Core.GenericCrud;
+
+namespace VirtoCommerce.Platform.Data.GenericCrud;
+
+/// <summary>
+/// Generic service to simplify CRUD implementation with outer entities.
+/// To implement the service for applied purpose, inherit your search service from this.
+/// </summary>
+/// <typeparam name="TModel">The type of service layer model</typeparam>
+/// <typeparam name="TEntity">The type of data access layer entity (EF) </typeparam>
+/// <typeparam name="TChangingEvent">The type of *changing event</typeparam>
+/// <typeparam name="TChangedEvent">The type of *changed event</typeparam>
+public abstract class OuterEntityService<TModel, TEntity, TChangingEvent, TChangedEvent>
+    : CrudService<TModel, TEntity, TChangingEvent, TChangedEvent>, IOuterEntityService<TModel>
+    where TModel : Entity, IHasOuterId, ICloneable
+    where TEntity : Entity, IHasOuterId, IDataEntity<TEntity, TModel>
+    where TChangingEvent : GenericChangedEntryEvent<TModel>
+    where TChangedEvent : GenericChangedEntryEvent<TModel>
+{
+    private readonly Func<IRepository> _repositoryFactory;
+
+    /// <summary>
+    /// Construct new OuterEntityService
+    /// </summary>
+    /// <param name="repositoryFactory">Repository factory to get access to the data source</param>
+    /// <param name="platformMemoryCache">The cache used to temporarily store returned values</param>
+    /// <param name="eventPublisher">The publisher to propagate platform-wide events (TChangingEvent, TChangedEvent)</param>
+    protected OuterEntityService(Func<IRepository> repositoryFactory, IPlatformMemoryCache platformMemoryCache, IEventPublisher eventPublisher)
+        : base(repositoryFactory, platformMemoryCache, eventPublisher)
+    {
+        _repositoryFactory = repositoryFactory;
+    }
+
+    public virtual async Task<IList<TModel>> GetByOuterIdsAsync(IList<string> outerIds, string responseGroup = null, bool clone = true)
+    {
+        using var repository = _repositoryFactory();
+
+        var query = GetEntitiesQuery(repository);
+
+        query = outerIds.Count == 1
+            ? query.Where(x => x.OuterId.Equals(outerIds[0]))
+            : query.Where(x => outerIds.Contains(x.OuterId));
+
+        var ids = await query
+            .Select(x => x.Id)
+            .ToArrayAsync();
+
+        if (ids.Length == 0)
+        {
+            return [];
+        }
+
+        return await GetAsync(ids, responseGroup, clone);
+    }
+
+    protected abstract IQueryable<TEntity> GetEntitiesQuery(IRepository repository);
+}

src/VirtoCommerce.Platform.Data/Infrastructure/DbContextRepositoryBase.cs

@@ -100,6 +100,5 @@ protected virtual void Dispose(bool disposing)
             }
         }
         #endregion
-
     }
 }