Add AddDefaultRepository method

framework/src/Volo.Abp.Ddd.Domain/Volo/Abp/DependencyInjection/AbpCommonDbContextRegistrationOptions.cs

@@ -29,6 +29,8 @@ namespace Volo.Abp.DependencyInjection
 
         public Dictionary<Type, Type> CustomRepositories { get; }
 
+        public List<Type> DefaultRepositories { get; }
+
         public bool SpecifiedDefaultRepositoryTypes => DefaultRepositoryImplementationType != null && DefaultRepositoryImplementationTypeWithoutKey != null;
 
         protected AbpCommonDbContextRegistrationOptions(Type originalDbContextType, IServiceCollection services)
@@ -38,6 +40,7 @@ namespace Volo.Abp.DependencyInjection
             DefaultRepositoryDbContextType = originalDbContextType;
             CustomRepositories = new Dictionary<Type, Type>();
             ReplacedDbContextTypes = new List<Type>();
+            DefaultRepositories = new List<Type>();
         }
 
         public IAbpCommonDbContextRegistrationOptionsBuilder ReplaceDbContext<TOtherDbContext>()
@@ -82,6 +85,23 @@ namespace Volo.Abp.DependencyInjection
             return AddDefaultRepositories(typeof(TDefaultRepositoryDbContext), includeAllEntities);
         }
 
+        public IAbpCommonDbContextRegistrationOptionsBuilder AddDefaultRepository<TEntity>()
+        {
+            return AddDefaultRepository(typeof(TEntity));
+        }
+
+        public IAbpCommonDbContextRegistrationOptionsBuilder AddDefaultRepository(Type entityType)
+        {
+            if (!typeof(IEntity).IsAssignableFrom(entityType))
+            {
+                throw new AbpException($"Given entityType is not an entity: {entityType.AssemblyQualifiedName}. It must implement {typeof(IEntity<>).AssemblyQualifiedName}.");
+            }
+
+            DefaultRepositories.AddIfNotContains(entityType);
+
+            return this;
+        }
+
         public IAbpCommonDbContextRegistrationOptionsBuilder AddRepository<TEntity, TRepository>()
         {
             AddCustomRepository(typeof(TEntity), typeof(TRepository));
@@ -118,4 +138,4 @@ namespace Volo.Abp.DependencyInjection
             CustomRepositories[entityType] = repositoryType;
         }
     }
-}
+}

framework/src/Volo.Abp.Ddd.Domain/Volo/Abp/DependencyInjection/IAbpCommonDbContextRegistrationOptionsBuilder.cs

@@ -39,6 +39,20 @@ namespace Volo.Abp.DependencyInjection
         /// </param>
         IAbpCommonDbContextRegistrationOptionsBuilder AddDefaultRepositories(Type defaultRepositoryDbContextType, bool includeAllEntities = false);
 
+        /// <summary>
+        /// Registers custom repository for a specific entity.
+        /// </summary>
+        /// <typeparam name="TEntity">Entity type</typeparam>
+        IAbpCommonDbContextRegistrationOptionsBuilder AddDefaultRepository<TEntity>();
+
+
+        /// <summary>
+        /// Registers default repository for a specific entity.
+        /// </summary>
+        /// <param name="entityType"></param>
+        /// <returns></returns>
+        IAbpCommonDbContextRegistrationOptionsBuilder AddDefaultRepository(Type entityType);
+
         /// <summary>
         /// Registers custom repository for a specific entity.
         /// Custom repositories overrides default repositories.

framework/src/Volo.Abp.Ddd.Domain/Volo/Abp/Domain/Repositories/RepositoryRegistrarBase.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Microsoft.Extensions.DependencyInjection;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Domain.Entities;
@@ -27,6 +28,12 @@ namespace Volo.Abp.Domain.Repositories
             {
                 RegisterDefaultRepositories();
             }
+
+            foreach (var entityType in Options.DefaultRepositories)
+            {
+                ShouldRegisterDefaultRepositoryFor(entityType);
+                RegisterDefaultRepository(entityType);
+            }
         }
 
         protected virtual void RegisterDefaultRepositories()
@@ -68,7 +75,7 @@ namespace Volo.Abp.Domain.Repositories
 
         protected virtual bool ShouldRegisterDefaultRepositoryFor(Type entityType)
         {
-            if (!Options.RegisterDefaultRepositories)
+            if (!Options.RegisterDefaultRepositories && !Options.DefaultRepositories.Any())
             {
                 return false;
             }
@@ -78,6 +85,11 @@ namespace Volo.Abp.Domain.Repositories
                 return false;
             }
 
+            if (Options.DefaultRepositories.Contains(entityType))
+            {
+                return true;
+            }
+
             if (!Options.IncludeAllEntitiesForDefaultRepositories && !typeof(IAggregateRoot).IsAssignableFrom(entityType))
             {
                 return false;
@@ -92,4 +104,4 @@ namespace Volo.Abp.Domain.Repositories
 
         protected abstract Type GetRepositoryType(Type dbContextType, Type entityType, Type primaryKeyType);
     }
-}
+}

framework/test/Volo.Abp.Ddd.Tests/Volo/Abp/Domain/Repositories/RepositoryRegistration_Tests.cs

@@ -189,6 +189,60 @@ namespace Volo.Abp.Domain.Repositories
             services.ShouldContainTransient(typeof(IRepository<MyTestEntityWithInt32Pk, int>), typeof(MyTestCustomBaseRepository<MyTestEntityWithInt32Pk, int>));
         }
 
+        [Fact]
+        public void Should_Register_Default_Repository()
+        {
+            //Arrange
+
+            var services = new ServiceCollection();
+
+            var options = new TestDbContextRegistrationOptions(typeof(MyFakeDbContext), services);
+            options.AddDefaultRepository<MyTestAggregateRootWithGuidPk>();
+
+            //Act
+
+            new MyTestRepositoryRegistrar(options).AddRepositories();
+
+            //MyTestAggregateRootWithoutPk
+            services.ShouldNotContainService(typeof(IReadOnlyRepository<MyTestAggregateRootWithoutPk>));
+            services.ShouldNotContainService(typeof(IBasicRepository<MyTestAggregateRootWithoutPk>));
+            services.ShouldNotContainService(typeof(IRepository<MyTestAggregateRootWithoutPk>));
+
+            //MyTestAggregateRootWithGuidPk
+            services.ShouldContainTransient(typeof(IReadOnlyRepository<MyTestAggregateRootWithGuidPk>), typeof(MyTestDefaultRepository<MyTestAggregateRootWithGuidPk, Guid>));
+            services.ShouldContainTransient(typeof(IBasicRepository<MyTestAggregateRootWithGuidPk>), typeof(MyTestDefaultRepository<MyTestAggregateRootWithGuidPk, Guid>));
+            services.ShouldContainTransient(typeof(IRepository<MyTestAggregateRootWithGuidPk>), typeof(MyTestDefaultRepository<MyTestAggregateRootWithGuidPk, Guid>));
+            services.ShouldContainTransient(typeof(IReadOnlyRepository<MyTestAggregateRootWithGuidPk, Guid>), typeof(MyTestDefaultRepository<MyTestAggregateRootWithGuidPk, Guid>));
+            services.ShouldContainTransient(typeof(IBasicRepository<MyTestAggregateRootWithGuidPk, Guid>), typeof(MyTestDefaultRepository<MyTestAggregateRootWithGuidPk, Guid>));
+            services.ShouldContainTransient(typeof(IRepository<MyTestAggregateRootWithGuidPk, Guid>), typeof(MyTestDefaultRepository<MyTestAggregateRootWithGuidPk, Guid>));
+        }
+
+        [Fact]
+        public void Should_Not_Register_Default_Repository_If_Registered_Custom_Repository()
+        {
+            //Arrange
+
+            var services = new ServiceCollection();
+
+            var options = new TestDbContextRegistrationOptions(typeof(MyFakeDbContext), services);
+            options
+                .AddDefaultRepository<MyTestAggregateRootWithGuidPk>()
+                .AddRepository<MyTestAggregateRootWithGuidPk, MyTestAggregateRootWithDefaultPkCustomRepository>();;
+
+            //Act
+
+            new MyTestRepositoryRegistrar(options).AddRepositories();
+
+            //MyTestAggregateRootWithGuidPk
+            services.ShouldContainTransient(typeof(IReadOnlyRepository<MyTestAggregateRootWithGuidPk>), typeof(MyTestAggregateRootWithDefaultPkCustomRepository));
+            services.ShouldContainTransient(typeof(IBasicRepository<MyTestAggregateRootWithGuidPk>), typeof(MyTestAggregateRootWithDefaultPkCustomRepository));
+            services.ShouldContainTransient(typeof(IRepository<MyTestAggregateRootWithGuidPk>), typeof(MyTestAggregateRootWithDefaultPkCustomRepository));
+            services.ShouldContainTransient(typeof(IReadOnlyRepository<MyTestAggregateRootWithGuidPk, Guid>), typeof(MyTestAggregateRootWithDefaultPkCustomRepository));
+            services.ShouldContainTransient(typeof(IReadOnlyBasicRepository<MyTestAggregateRootWithGuidPk, Guid>), typeof(MyTestAggregateRootWithDefaultPkCustomRepository));
+            services.ShouldContainTransient(typeof(IBasicRepository<MyTestAggregateRootWithGuidPk, Guid>), typeof(MyTestAggregateRootWithDefaultPkCustomRepository));
+            services.ShouldContainTransient(typeof(IRepository<MyTestAggregateRootWithGuidPk, Guid>), typeof(MyTestAggregateRootWithDefaultPkCustomRepository));
+        }
+
         public class MyTestRepositoryRegistrar : RepositoryRegistrarBase<AbpCommonDbContextRegistrationOptions>
         {
             public MyTestRepositoryRegistrar(AbpCommonDbContextRegistrationOptions options)