Merge branch 'dev' of https://github.com/abpframework/abp into dev

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;
@@ -17,20 +18,29 @@ namespace Volo.Abp.Domain.Repositories
         }
 
         public virtual void AddRepositories()
+        {
+            RegisterCustomRepositories();
+
+            RegisterDefaultRepositories();
+
+            RegisterSpecifiedDefaultRepositories();
+        }
+
+        protected virtual void RegisterCustomRepositories()
         {
             foreach (var customRepository in Options.CustomRepositories)
             {
                 Options.Services.AddDefaultRepository(customRepository.Key, customRepository.Value, replaceExisting: true);
             }
-
-            if (Options.RegisterDefaultRepositories)
-            {
-                RegisterDefaultRepositories();
-            }
         }
 
         protected virtual void RegisterDefaultRepositories()
         {
+            if (!Options.RegisterDefaultRepositories)
+            {
+                return;
+            }
+
             foreach (var entityType in GetEntityTypes(Options.OriginalDbContextType))
             {
                 if (!ShouldRegisterDefaultRepositoryFor(entityType))
@@ -42,6 +52,17 @@ namespace Volo.Abp.Domain.Repositories
             }
         }
 
+        protected virtual void RegisterSpecifiedDefaultRepositories()
+        {
+            foreach (var entityType in Options.DefaultRepositories)
+            {
+                if (!Options.CustomRepositories.ContainsKey(entityType))
+                {
+                    RegisterDefaultRepository(entityType);
+                }
+            }
+        }
+
         protected virtual void RegisterDefaultRepository(Type entityType)
         {
             Options.Services.AddDefaultRepository(
@@ -92,4 +113,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)

modules/audit-logging/src/Volo.Abp.AuditLogging.EntityFrameworkCore/Volo/Abp/AuditLogging/EntityFrameworkCore/IAuditLoggingDbContext.cs

@@ -7,6 +7,6 @@ namespace Volo.Abp.AuditLogging.EntityFrameworkCore
     [ConnectionStringName(AbpAuditLoggingDbProperties.ConnectionStringName)]
     public interface IAuditLoggingDbContext : IEfCoreDbContext
     {
-        DbSet<AuditLog> AuditLogs { get; set; }
+        DbSet<AuditLog> AuditLogs { get; }
     }
 }

modules/blogging/src/Volo.Blogging.EntityFrameworkCore/Volo/Blogging/EntityFrameworkCore/IBloggingDbContext.cs

@@ -16,14 +16,14 @@ namespace Volo.Blogging.EntityFrameworkCore
     {
         DbSet<BlogUser> Users { get; }
 
-        DbSet<Blog> Blogs { get; set; }
+        DbSet<Blog> Blogs { get; }
 
-        DbSet<Post> Posts { get; set; }
+        DbSet<Post> Posts { get; }
 
-        DbSet<Comment> Comments { get; set; }
+        DbSet<Comment> Comments { get; }
 
-        DbSet<PostTag> PostTags { get; set; }
+        DbSet<PostTag> PostTags { get; }
 
-        DbSet<Tag> Tags { get; set; }
+        DbSet<Tag> Tags { get; }
     }
 }

modules/cms-kit/src/Volo.CmsKit.EntityFrameworkCore/Volo/CmsKit/EntityFrameworkCore/ICmsKitDbContext.cs

@@ -16,16 +16,16 @@ namespace Volo.CmsKit.EntityFrameworkCore
     [ConnectionStringName(CmsKitDbProperties.ConnectionStringName)]
     public interface ICmsKitDbContext : IEfCoreDbContext
     {
-        DbSet<Content> Contents { get; set; }
-        DbSet<Comment> Comments { get; set; }
-        DbSet<CmsUser> User { get; set; }
-        DbSet<UserReaction> Reactions { get; set; }
-        DbSet<Rating> Ratings { get; set; }
-        DbSet<Tag> Tags { get; set; }
-        DbSet<EntityTag> EntityTags { get; set; }
-        DbSet<Page> Pages { get; set; }
-        DbSet<Blog> Blogs { get; set; }
-        DbSet<BlogPost> BlogPosts { get; set; }
-        DbSet<MediaDescriptor> MediaDescriptors { get; set; }
+        DbSet<Content> Contents { get; }
+        DbSet<Comment> Comments { get; }
+        DbSet<CmsUser> User { get; }
+        DbSet<UserReaction> Reactions { get; }
+        DbSet<Rating> Ratings { get; }
+        DbSet<Tag> Tags { get; }
+        DbSet<EntityTag> EntityTags { get; }
+        DbSet<Page> Pages { get; }
+        DbSet<Blog> Blogs { get; }
+        DbSet<BlogPost> BlogPosts { get; }
+        DbSet<MediaDescriptor> MediaDescriptors { get; }
     }
 }

modules/docs/src/Volo.Docs.EntityFrameworkCore/Volo/Docs/EntityFrameworkCore/IDocsDbContext.cs

@@ -11,10 +11,10 @@ namespace Volo.Docs.EntityFrameworkCore
     [ConnectionStringName(DocsDbProperties.ConnectionStringName)]
     public interface IDocsDbContext : IEfCoreDbContext
     {
-        DbSet<Project> Projects { get; set; }
+        DbSet<Project> Projects { get; }
 
-        DbSet<Document> Documents { get; set; }
+        DbSet<Document> Documents { get; }
 
-        DbSet<DocumentContributor> DocumentContributors { get; set; }
+        DbSet<DocumentContributor> DocumentContributors { get; }
     }
 }

modules/feature-management/src/Volo.Abp.FeatureManagement.EntityFrameworkCore/Volo/Abp/FeatureManagement/EntityFrameworkCore/IFeatureManagementDbContext.cs

@@ -9,6 +9,6 @@ namespace Volo.Abp.FeatureManagement.EntityFrameworkCore
     [ConnectionStringName(FeatureManagementDbProperties.ConnectionStringName)]
     public interface IFeatureManagementDbContext : IEfCoreDbContext
     {
-        DbSet<FeatureValue> FeatureValues { get; set; }
+        DbSet<FeatureValue> FeatureValues { get; }
     }
 }

modules/identity/src/Volo.Abp.Identity.EntityFrameworkCore/Volo/Abp/Identity/EntityFrameworkCore/IIdentityDbContext.cs

@@ -7,16 +7,16 @@ namespace Volo.Abp.Identity.EntityFrameworkCore
     [ConnectionStringName(AbpIdentityDbProperties.ConnectionStringName)]
     public interface IIdentityDbContext : IEfCoreDbContext
     {
-        DbSet<IdentityUser> Users { get; set; }
+        DbSet<IdentityUser> Users { get; }
 
-        DbSet<IdentityRole> Roles { get; set; }
+        DbSet<IdentityRole> Roles { get; }
 
-        DbSet<IdentityClaimType> ClaimTypes { get; set; }
+        DbSet<IdentityClaimType> ClaimTypes { get; }
 
-        DbSet<OrganizationUnit> OrganizationUnits { get; set; }
+        DbSet<OrganizationUnit> OrganizationUnits { get; }
 
-        DbSet<IdentitySecurityLog> SecurityLogs { get; set; }
+        DbSet<IdentitySecurityLog> SecurityLogs { get; }
 
-        DbSet<IdentityLinkUser> LinkUsers { get; set; }
+        DbSet<IdentityLinkUser> LinkUsers { get; }
     }
 }

modules/identityserver/src/Volo.Abp.IdentityServer.EntityFrameworkCore/Volo/Abp/IdentityServer/EntityFrameworkCore/IIdentityServerDbContext.cs

@@ -17,64 +17,64 @@ namespace Volo.Abp.IdentityServer.EntityFrameworkCore
     {
         #region ApiResource
 
-        DbSet<ApiResource> ApiResources { get; set; }
+        DbSet<ApiResource> ApiResources { get; }
 
-        DbSet<ApiResourceSecret> ApiResourceSecrets { get; set; }
+        DbSet<ApiResourceSecret> ApiResourceSecrets { get; }
 
-        DbSet<ApiResourceClaim> ApiResourceClaims { get; set; }
+        DbSet<ApiResourceClaim> ApiResourceClaims { get; }
 
-        DbSet<ApiResourceScope> ApiResourceScopes { get; set; }
+        DbSet<ApiResourceScope> ApiResourceScopes { get; }
 
-        DbSet<ApiResourceProperty> ApiResourceProperties { get; set; }
+        DbSet<ApiResourceProperty> ApiResourceProperties { get; }
 
         #endregion
 
         #region ApiScope
 
-        DbSet<ApiScope> ApiScopes { get; set; }
+        DbSet<ApiScope> ApiScopes { get; }
 
-        DbSet<ApiScopeClaim> ApiScopeClaims { get; set; }
+        DbSet<ApiScopeClaim> ApiScopeClaims { get; }
 
-        DbSet<ApiScopeProperty> ApiScopeProperties { get; set; }
+        DbSet<ApiScopeProperty> ApiScopeProperties { get; }
 
         #endregion
 
         #region IdentityResource
 
-        DbSet<IdentityResource> IdentityResources { get; set; }
+        DbSet<IdentityResource> IdentityResources { get; }
 
-        DbSet<IdentityResourceClaim> IdentityClaims { get; set; }
+        DbSet<IdentityResourceClaim> IdentityClaims { get; }
 
-        DbSet<IdentityResourceProperty> IdentityResourceProperties { get; set; }
+        DbSet<IdentityResourceProperty> IdentityResourceProperties { get; }
 
         #endregion
 
         #region Client
 
-        DbSet<Client> Clients { get; set; }
+        DbSet<Client> Clients { get; }
 
-        DbSet<ClientGrantType> ClientGrantTypes { get; set; }
+        DbSet<ClientGrantType> ClientGrantTypes { get; }
 
-        DbSet<ClientRedirectUri> ClientRedirectUris { get; set; }
+        DbSet<ClientRedirectUri> ClientRedirectUris { get; }
 
-        DbSet<ClientPostLogoutRedirectUri> ClientPostLogoutRedirectUris { get; set; }
+        DbSet<ClientPostLogoutRedirectUri> ClientPostLogoutRedirectUris { get; }
 
-        DbSet<ClientScope> ClientScopes { get; set; }
+        DbSet<ClientScope> ClientScopes { get; }
 
-        DbSet<ClientSecret> ClientSecrets { get; set; }
+        DbSet<ClientSecret> ClientSecrets { get; }
 
-        DbSet<ClientClaim> ClientClaims { get; set; }
+        DbSet<ClientClaim> ClientClaims { get; }
 
-        DbSet<ClientIdPRestriction> ClientIdPRestrictions { get; set; }
+        DbSet<ClientIdPRestriction> ClientIdPRestrictions { get; }
 
-        DbSet<ClientCorsOrigin> ClientCorsOrigins { get; set; }
+        DbSet<ClientCorsOrigin> ClientCorsOrigins { get; }
 
-        DbSet<ClientProperty> ClientProperties { get; set; }
+        DbSet<ClientProperty> ClientProperties { get; }
 
             #endregion
 
-        DbSet<PersistedGrant> PersistedGrants { get; set; }
+        DbSet<PersistedGrant> PersistedGrants { get; }
 
-        DbSet<DeviceFlowCodes> DeviceFlowCodes { get; set; }
+        DbSet<DeviceFlowCodes> DeviceFlowCodes { get; }
     }
 }

modules/permission-management/src/Volo.Abp.PermissionManagement.EntityFrameworkCore/Volo/Abp/PermissionManagement/EntityFrameworkCore/IPermissionManagementDbContext.cs

@@ -7,6 +7,6 @@ namespace Volo.Abp.PermissionManagement.EntityFrameworkCore
     [ConnectionStringName(AbpPermissionManagementDbProperties.ConnectionStringName)]
     public interface IPermissionManagementDbContext : IEfCoreDbContext
     {
-        DbSet<PermissionGrant> PermissionGrants { get; set; }
+        DbSet<PermissionGrant> PermissionGrants { get; }
     }
 }

modules/setting-management/src/Volo.Abp.SettingManagement.EntityFrameworkCore/Volo/Abp/SettingManagement/EntityFrameworkCore/ISettingManagementDbContext.cs

@@ -9,6 +9,6 @@ namespace Volo.Abp.SettingManagement.EntityFrameworkCore
     [ConnectionStringName(AbpSettingManagementDbProperties.ConnectionStringName)]
     public interface ISettingManagementDbContext : IEfCoreDbContext
     {
-        DbSet<Setting> Settings { get; set; }
+        DbSet<Setting> Settings { get; }
     }
 }

modules/tenant-management/src/Volo.Abp.TenantManagement.EntityFrameworkCore/Volo/Abp/TenantManagement/EntityFrameworkCore/ITenantManagementDbContext.cs

@@ -9,8 +9,8 @@ namespace Volo.Abp.TenantManagement.EntityFrameworkCore
     [ConnectionStringName(AbpTenantManagementDbProperties.ConnectionStringName)]
     public interface ITenantManagementDbContext : IEfCoreDbContext
     {
-        DbSet<Tenant> Tenants { get; set; }
+        DbSet<Tenant> Tenants { get; }
 
-        DbSet<TenantConnectionString> TenantConnectionStrings { get; set; }
+        DbSet<TenantConnectionString> TenantConnectionStrings { get; }
     }
 }