Fixed #5215: When tiered templates, tenants of independent databases cannot login (AngularUI).

framework/src/Volo.Abp.EntityFrameworkCore/Volo/Abp/EntityFrameworkCore/DependencyInjection/DbContextOptionsFactory.cs

@@ -4,6 +4,7 @@ using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 using Volo.Abp.Data;
+using Volo.Abp.MultiTenancy;
 
 namespace Volo.Abp.EntityFrameworkCore.DependencyInjection
 {
@@ -86,16 +87,34 @@ namespace Volo.Abp.EntityFrameworkCore.DependencyInjection
             }
 
             var connectionStringName = ConnectionStringNameAttribute.GetConnStringName<TDbContext>();
-
-            //Use DefaultConnectionStringResolver.Resolve when we remove IConnectionStringResolver.Resolve
-#pragma warning disable 618
-            var connectionString = serviceProvider.GetRequiredService<IConnectionStringResolver>().Resolve(connectionStringName);
-#pragma warning restore 618
+            var connectionString = ResolveConnectionString<TDbContext>(serviceProvider, connectionStringName);
 
             return new DbContextCreationContext(
                 connectionStringName,
                 connectionString
             );
         }
+
+        private static string ResolveConnectionString<TDbContext>(
+            IServiceProvider serviceProvider,
+            string connectionStringName)
+        {
+            // Use DefaultConnectionStringResolver.Resolve when we remove IConnectionStringResolver.Resolve
+#pragma warning disable 618
+            var connectionStringResolver = serviceProvider.GetRequiredService<IConnectionStringResolver>();
+            var currentTenant = serviceProvider.GetRequiredService<ICurrentTenant>();
+
+            // Multi-tenancy unaware contexts should always use the host connection string
+            if (typeof(TDbContext).IsDefined(typeof(IgnoreMultiTenancyAttribute), false))
+            {
+                using (currentTenant.Change(null))
+                {
+                    return connectionStringResolver.Resolve(connectionStringName);
+                }
+            }
+
+            return connectionStringResolver.Resolve(connectionStringName);
+#pragma warning restore 618
+        }
     }
 }

framework/src/Volo.Abp.EntityFrameworkCore/Volo/Abp/Uow/EntityFrameworkCore/UnitOfWorkDbContextProvider.cs

@@ -9,6 +9,7 @@ using Microsoft.Extensions.Logging.Abstractions;
 using Volo.Abp.Data;
 using Volo.Abp.EntityFrameworkCore;
 using Volo.Abp.EntityFrameworkCore.DependencyInjection;
+using Volo.Abp.MultiTenancy;
 using Volo.Abp.Threading;
 
 namespace Volo.Abp.Uow.EntityFrameworkCore
@@ -23,15 +24,18 @@ namespace Volo.Abp.Uow.EntityFrameworkCore
         private readonly IUnitOfWorkManager _unitOfWorkManager;
         private readonly IConnectionStringResolver _connectionStringResolver;
         private readonly ICancellationTokenProvider _cancellationTokenProvider;
+        private readonly ICurrentTenant _currentTenant;
 
         public UnitOfWorkDbContextProvider(
             IUnitOfWorkManager unitOfWorkManager,
             IConnectionStringResolver connectionStringResolver,
-            ICancellationTokenProvider cancellationTokenProvider)
+            ICancellationTokenProvider cancellationTokenProvider,
+            ICurrentTenant currentTenant)
         {
             _unitOfWorkManager = unitOfWorkManager;
             _connectionStringResolver = connectionStringResolver;
             _cancellationTokenProvider = cancellationTokenProvider;
+            _currentTenant = currentTenant;
 
             Logger = NullLogger<UnitOfWorkDbContextProvider<TDbContext>>.Instance;
         }
@@ -57,7 +61,7 @@ namespace Volo.Abp.Uow.EntityFrameworkCore
             }
 
             var connectionStringName = ConnectionStringNameAttribute.GetConnStringName<TDbContext>();
-            var connectionString = _connectionStringResolver.Resolve(connectionStringName);
+            var connectionString = ResolveConnectionString(connectionStringName);
 
             var dbContextKey = $"{typeof(TDbContext).FullName}_{connectionString}";
 
@@ -79,7 +83,7 @@ namespace Volo.Abp.Uow.EntityFrameworkCore
             }
 
             var connectionStringName = ConnectionStringNameAttribute.GetConnStringName<TDbContext>();
-            var connectionString = await _connectionStringResolver.ResolveAsync(connectionStringName);
+            var connectionString = await ResolveConnectionStringAsync(connectionStringName);
 
             var dbContextKey = $"{typeof(TDbContext).FullName}_{connectionString}";
 
@@ -241,6 +245,35 @@ namespace Volo.Abp.Uow.EntityFrameworkCore
             }
         }
 
+        private async Task<string> ResolveConnectionStringAsync(string connectionStringName)
+        {
+            // Multi-tenancy unaware contexts should always use the host connection string
+            if (typeof(TDbContext).IsDefined(typeof(IgnoreMultiTenancyAttribute), false))
+            {
+                using (_currentTenant.Change(null))
+                {
+                    return await _connectionStringResolver.ResolveAsync(connectionStringName);
+                }
+            }
+
+            return await _connectionStringResolver.ResolveAsync(connectionStringName);
+        }
+
+        [Obsolete("Use ResolveConnectionStringAsync method.")]
+        private string ResolveConnectionString(string connectionStringName)
+        {
+            // Multi-tenancy unaware contexts should always use the host connection string
+            if (typeof(TDbContext).IsDefined(typeof(IgnoreMultiTenancyAttribute), false))
+            {
+                using (_currentTenant.Change(null))
+                {
+                    return _connectionStringResolver.Resolve(connectionStringName);
+                }
+            }
+
+            return _connectionStringResolver.Resolve(connectionStringName);
+        }
+
         protected virtual CancellationToken GetCancellationToken(CancellationToken preferredValue = default)
         {
             return _cancellationTokenProvider.FallbackToProvider(preferredValue);

framework/src/Volo.Abp.MemoryDb/Volo/Abp/Uow/MemoryDb/UnitOfWorkMemoryDatabaseProvider.cs

@@ -3,6 +3,7 @@ using System.Threading.Tasks;
 using Volo.Abp.Data;
 using Volo.Abp.Domain.Repositories.MemoryDb;
 using Volo.Abp.MemoryDb;
+using Volo.Abp.MultiTenancy;
 
 namespace Volo.Abp.Uow.MemoryDb
 {
@@ -14,17 +15,20 @@ namespace Volo.Abp.Uow.MemoryDb
         private readonly IUnitOfWorkManager _unitOfWorkManager;
         private readonly IConnectionStringResolver _connectionStringResolver;
         private readonly MemoryDatabaseManager _memoryDatabaseManager;
+        private readonly ICurrentTenant _currentTenant;
 
         public UnitOfWorkMemoryDatabaseProvider(
             IUnitOfWorkManager unitOfWorkManager,
             IConnectionStringResolver connectionStringResolver,
             TMemoryDbContext dbContext,
-            MemoryDatabaseManager memoryDatabaseManager)
+            MemoryDatabaseManager memoryDatabaseManager,
+            ICurrentTenant currentTenant)
         {
             _unitOfWorkManager = unitOfWorkManager;
             _connectionStringResolver = connectionStringResolver;
             DbContext = dbContext;
             _memoryDatabaseManager = memoryDatabaseManager;
+            _currentTenant = currentTenant;
         }
 
         public Task<TMemoryDbContext> GetDbContextAsync()
@@ -72,5 +76,34 @@ namespace Volo.Abp.Uow.MemoryDb
 
             return ((MemoryDbDatabaseApi)databaseApi).Database;
         }
+
+        private async Task<string> ResolveConnectionStringAsync()
+        {
+            // Multi-tenancy unaware contexts should always use the host connection string
+            if (typeof(TMemoryDbContext).IsDefined(typeof(IgnoreMultiTenancyAttribute), false))
+            {
+                using (_currentTenant.Change(null))
+                {
+                    return await _connectionStringResolver.ResolveAsync<TMemoryDbContext>();
+                }
+            }
+
+            return await _connectionStringResolver.ResolveAsync<TMemoryDbContext>();
+        }
+
+        [Obsolete("Use ResolveConnectionStringAsync method.")]
+        private string ResolveConnectionString()
+        {
+            // Multi-tenancy unaware contexts should always use the host connection string
+            if (typeof(TMemoryDbContext).IsDefined(typeof(IgnoreMultiTenancyAttribute), false))
+            {
+                using (_currentTenant.Change(null))
+                {
+                    return _connectionStringResolver.Resolve<TMemoryDbContext>();
+                }
+            }
+
+            return _connectionStringResolver.Resolve<TMemoryDbContext>();
+        }
     }
 }

framework/src/Volo.Abp.MongoDB/Volo/Abp/Uow/MongoDB/UnitOfWorkMongoDbContextProvider.cs

@@ -8,6 +8,7 @@ using MongoDB.Bson;
 using MongoDB.Driver;
 using Volo.Abp.Data;
 using Volo.Abp.MongoDB;
+using Volo.Abp.MultiTenancy;
 using Volo.Abp.Threading;
 
 namespace Volo.Abp.Uow.MongoDB
@@ -20,15 +21,18 @@ namespace Volo.Abp.Uow.MongoDB
         private readonly IUnitOfWorkManager _unitOfWorkManager;
         private readonly IConnectionStringResolver _connectionStringResolver;
         private readonly ICancellationTokenProvider _cancellationTokenProvider;
+        private readonly ICurrentTenant _currentTenant;
 
         public UnitOfWorkMongoDbContextProvider(
             IUnitOfWorkManager unitOfWorkManager,
             IConnectionStringResolver connectionStringResolver,
-            ICancellationTokenProvider cancellationTokenProvider)
+            ICancellationTokenProvider cancellationTokenProvider,
+            ICurrentTenant currentTenant)
         {
             _unitOfWorkManager = unitOfWorkManager;
             _connectionStringResolver = connectionStringResolver;
             _cancellationTokenProvider = cancellationTokenProvider;
+            _currentTenant = currentTenant;
 
             Logger = NullLogger<UnitOfWorkMongoDbContextProvider<TMongoDbContext>>.Instance;
         }
@@ -54,7 +58,7 @@ namespace Volo.Abp.Uow.MongoDB
                     $"A {nameof(IMongoDatabase)} instance can only be created inside a unit of work!");
             }
 
-            var connectionString = _connectionStringResolver.Resolve<TMongoDbContext>();
+            var connectionString = ResolveConnectionString();
             var dbContextKey = $"{typeof(TMongoDbContext).FullName}_{connectionString}";
 
             var mongoUrl = new MongoUrl(connectionString);
@@ -81,7 +85,7 @@ namespace Volo.Abp.Uow.MongoDB
                     $"A {nameof(IMongoDatabase)} instance can only be created inside a unit of work!");
             }
 
-            var connectionString = await _connectionStringResolver.ResolveAsync<TMongoDbContext>();
+            var connectionString = await ResolveConnectionStringAsync();
             var dbContextKey = $"{typeof(TMongoDbContext).FullName}_{connectionString}";
 
             var mongoUrl = new MongoUrl(connectionString);
@@ -234,6 +238,35 @@ namespace Volo.Abp.Uow.MongoDB
             return dbContext;
         }
 
+        private async Task<string> ResolveConnectionStringAsync()
+        {
+            // Multi-tenancy unaware contexts should always use the host connection string
+            if (typeof(TMongoDbContext).IsDefined(typeof(IgnoreMultiTenancyAttribute), false))
+            {
+                using (_currentTenant.Change(null))
+                {
+                    return await _connectionStringResolver.ResolveAsync<TMongoDbContext>();
+                }
+            }
+
+            return await _connectionStringResolver.ResolveAsync<TMongoDbContext>();
+        }
+
+        [Obsolete("Use ResolveConnectionStringAsync method.")]
+        private string ResolveConnectionString()
+        {
+            // Multi-tenancy unaware contexts should always use the host connection string
+            if (typeof(TMongoDbContext).IsDefined(typeof(IgnoreMultiTenancyAttribute), false))
+            {
+                using (_currentTenant.Change(null))
+                {
+                    return _connectionStringResolver.Resolve<TMongoDbContext>();
+                }
+            }
+
+            return _connectionStringResolver.Resolve<TMongoDbContext>();
+        }
+
         protected virtual CancellationToken GetCancellationToken(CancellationToken preferredValue = default)
         {
             return _cancellationTokenProvider.FallbackToProvider(preferredValue);

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

@@ -7,9 +7,11 @@ using Volo.Abp.IdentityServer.Clients;
 using Volo.Abp.IdentityServer.Devices;
 using Volo.Abp.IdentityServer.Grants;
 using Volo.Abp.IdentityServer.IdentityResources;
+using Volo.Abp.MultiTenancy;
 
 namespace Volo.Abp.IdentityServer.EntityFrameworkCore
 {
+    [IgnoreMultiTenancy]
     [ConnectionStringName(AbpIdentityServerDbProperties.ConnectionStringName)]
     public interface IIdentityServerDbContext : IEfCoreDbContext
     {

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

@@ -7,9 +7,11 @@ using Volo.Abp.IdentityServer.Clients;
 using Volo.Abp.IdentityServer.Devices;
 using Volo.Abp.IdentityServer.Grants;
 using Volo.Abp.IdentityServer.IdentityResources;
+using Volo.Abp.MultiTenancy;
 
 namespace Volo.Abp.IdentityServer.EntityFrameworkCore
 {
+    [IgnoreMultiTenancy]
     [ConnectionStringName(AbpIdentityServerDbProperties.ConnectionStringName)]
     public class IdentityServerDbContext : AbpDbContext<IdentityServerDbContext>, IIdentityServerDbContext
     {