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

docs/cs/docs-nav.json

@@ -264,7 +264,7 @@
           "items": [
             {
               "text": "PostgreSQL integrace",
-              "path": "Best-Practices/PostgreSQL-Integration.md"
+              "path": "EntityFrameworkCore-PostgreSQL-Integration.md"
             }
           ]
         },

docs/en/docs-nav.json

@@ -265,7 +265,7 @@
           "items": [            
             {
               "text": "PostgreSQL Integration",
-              "path": "Best-Practices/PostgreSQL-Integration.md"
+              "path": "EntityFrameworkCore-PostgreSQL-Integration.md"
             }
           ]
         },

docs/pt-BR/docs-nav.json

@@ -249,7 +249,7 @@
           "items": [
             {
               "text": "Integração do PostgreSQL",
-              "path": "Best-Practices/PostgreSQL-Integration.md"
+              "path": "EntityFrameworkCore-PostgreSQL-Integration.md"
             }
           ]
         },

docs/zh-Hans/docs-nav.json

@@ -254,7 +254,7 @@
           "items": [            
             {
               "text": "PostgreSQL 集成",
-              "path": "Best-Practices/PostgreSQL-Integration.md"
+              "path": "EntityFrameworkCore-PostgreSQL-Integration.md"
             }
           ]
         },

framework/src/Volo.Abp.AspNetCore.Mvc.Client/Volo/Abp/AspNetCore/Mvc/Client/CachedApplicationConfigurationClient.cs

@@ -7,6 +7,7 @@ using Volo.Abp.AspNetCore.Mvc.ApplicationConfigurations;
 using Volo.Abp.Caching;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Http.Client.DynamicProxying;
+using Volo.Abp.Threading;
 using Volo.Abp.Users;
 
 namespace Volo.Abp.AspNetCore.Mvc.Client
@@ -30,6 +31,33 @@ namespace Volo.Abp.AspNetCore.Mvc.Client
             Cache = cache;
         }
 
+        public ApplicationConfigurationDto Get()
+        {
+            var cacheKey = CreateCacheKey();
+            var httpContext = HttpContextAccessor?.HttpContext;
+
+            if (httpContext != null && httpContext.Items[cacheKey] is ApplicationConfigurationDto configuration)
+            {
+                return configuration;
+            }
+
+            configuration = Cache.GetOrAdd(
+                cacheKey,
+                () => AsyncHelper.RunSync(Proxy.Service.GetAsync),
+                () => new DistributedCacheEntryOptions
+                {
+                    AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(120) //TODO: Should be configurable. Default value should be higher (5 mins would be good).
+                }
+            );
+
+            if (httpContext != null)
+            {
+                httpContext.Items[cacheKey] = configuration;
+            }
+
+            return configuration;
+        }
+
         public async Task<ApplicationConfigurationDto> GetAsync()
         {
             var cacheKey = CreateCacheKey();

framework/src/Volo.Abp.AspNetCore.Mvc.Client/Volo/Abp/AspNetCore/Mvc/Client/ICachedApplicationConfigurationClient.cs

@@ -5,6 +5,8 @@ namespace Volo.Abp.AspNetCore.Mvc.Client
 {
     public interface ICachedApplicationConfigurationClient
     {
+        ApplicationConfigurationDto Get();
+
         Task<ApplicationConfigurationDto> GetAsync();
     }
 }

framework/src/Volo.Abp.AspNetCore.Mvc.Client/Volo/Abp/AspNetCore/Mvc/Client/RemoteLocalizationContributor.cs

@@ -55,9 +55,7 @@ namespace Volo.Abp.AspNetCore.Mvc.Client
 
         private Dictionary<string, string> GetResourceOrNull()
         {
-            var applicationConfigurationDto = AsyncHelper.RunSync(
-                () => _applicationConfigurationClient.GetAsync()
-            );
+            var applicationConfigurationDto = _applicationConfigurationClient.Get();
 
             var resource = applicationConfigurationDto
                 .Localization.Values

framework/src/Volo.Abp.AspNetCore.Mvc.Client/Volo/Abp/AspNetCore/Mvc/Client/RemoteTenantStore.cs

@@ -85,12 +85,58 @@ namespace Volo.Abp.AspNetCore.Mvc.Client
 
         public TenantConfiguration Find(string name)
         {
-            return AsyncHelper.RunSync(() => FindAsync(name));
+            var cacheKey = CreateCacheKey(name);
+            var httpContext = HttpContextAccessor?.HttpContext;
+
+            if (httpContext != null && httpContext.Items[cacheKey] is TenantConfiguration tenantConfiguration)
+            {
+                return tenantConfiguration;
+            }
+
+            tenantConfiguration = Cache.GetOrAdd(
+                cacheKey,
+                () => AsyncHelper.RunSync(async () => CreateTenantConfiguration(await Proxy.Service.FindTenantByNameAsync(name))),
+                () => new DistributedCacheEntryOptions
+                {
+                    AbsoluteExpirationRelativeToNow =
+                        TimeSpan.FromMinutes(5) //TODO: Should be configurable.
+                }
+            );
+
+            if (httpContext != null)
+            {
+                httpContext.Items[cacheKey] = tenantConfiguration;
+            }
+
+            return tenantConfiguration;
         }
 
         public TenantConfiguration Find(Guid id)
         {
-            return AsyncHelper.RunSync(() => FindAsync(id));
+            var cacheKey = CreateCacheKey(id);
+            var httpContext = HttpContextAccessor?.HttpContext;
+
+            if (httpContext != null && httpContext.Items[cacheKey] is TenantConfiguration tenantConfiguration)
+            {
+                return tenantConfiguration;
+            }
+            
+            tenantConfiguration = Cache.GetOrAdd(
+                cacheKey,
+                () => AsyncHelper.RunSync(async () => CreateTenantConfiguration(await Proxy.Service.FindTenantByIdAsync(id))),
+                () => new DistributedCacheEntryOptions
+                {
+                    AbsoluteExpirationRelativeToNow =
+                        TimeSpan.FromMinutes(5) //TODO: Should be configurable.
+                }
+            );
+
+            if (httpContext != null)
+            {
+                httpContext.Items[cacheKey] = tenantConfiguration;
+            }
+
+            return tenantConfiguration;
         }
 
         protected virtual TenantConfiguration CreateTenantConfiguration(FindTenantResultDto tenantResultDto)

framework/src/Volo.Abp.AspNetCore.Mvc/Volo/Abp/AspNetCore/Mvc/ApplicationConfigurations/AbpApplicationConfigurationAppService.cs

@@ -6,6 +6,7 @@ using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
 using Volo.Abp.Application.Services;
 using Volo.Abp.Authorization;
 using Volo.Abp.Features;
@@ -34,7 +35,7 @@ namespace Volo.Abp.AspNetCore.Mvc.ApplicationConfigurations
             IAuthorizationService authorizationService,
             ICurrentUser currentUser,
             ISettingProvider settingProvider,
-            SettingDefinitionManager settingDefinitionManager,
+            ISettingDefinitionManager settingDefinitionManager,
             IFeatureDefinitionManager featureDefinitionManager,
             ILanguageProvider languageProvider)
         {
@@ -76,23 +77,35 @@ namespace Volo.Abp.AspNetCore.Mvc.ApplicationConfigurations
 
         protected virtual async Task<ApplicationAuthConfigurationDto> GetAuthConfigAsync()
         {
+            Logger.LogDebug("Executing AbpApplicationConfigurationAppService.GetAuthConfigAsync()");
+
             var authConfig = new ApplicationAuthConfigurationDto();
 
-            foreach (var policyName in await _abpAuthorizationPolicyProvider.GetPoliciesNamesAsync())
+            var policyNames = await _abpAuthorizationPolicyProvider.GetPoliciesNamesAsync();
+
+            Logger.LogDebug($"GetPoliciesNamesAsync returns {policyNames.Count} items.");
+
+            foreach (var policyName in policyNames)
             {
                 authConfig.Policies[policyName] = true;
 
+                Logger.LogDebug($"_authorizationService.IsGrantedAsync? {policyName}");
+
                 if (await _authorizationService.IsGrantedAsync(policyName))
                 {
                     authConfig.GrantedPolicies[policyName] = true;
                 }
             }
 
+            Logger.LogDebug("Executed AbpApplicationConfigurationAppService.GetAuthConfigAsync()");
+
             return authConfig;
         }
 
         protected virtual async Task<ApplicationLocalizationConfigurationDto> GetLocalizationConfigAsync()
         {
+            Logger.LogDebug("Executing AbpApplicationConfigurationAppService.GetLocalizationConfigAsync()");
+
             var localizationConfig = new ApplicationLocalizationConfigurationDto();
 
             localizationConfig.Languages.AddRange(await _languageProvider.GetLanguagesAsync());
@@ -115,12 +128,14 @@ namespace Volo.Abp.AspNetCore.Mvc.ApplicationConfigurations
 
             localizationConfig.CurrentCulture = GetCurrentCultureInfo();
 
+            Logger.LogDebug("Executed AbpApplicationConfigurationAppService.GetLocalizationConfigAsync()");
+
             return localizationConfig;
         }
 
         private static CurrentCultureDto GetCurrentCultureInfo()
         {
-           return new CurrentCultureDto
+            return new CurrentCultureDto
             {
                 Name = CultureInfo.CurrentUICulture.Name,
                 DisplayName = CultureInfo.CurrentUICulture.DisplayName,
@@ -145,6 +160,8 @@ namespace Volo.Abp.AspNetCore.Mvc.ApplicationConfigurations
 
         private async Task<ApplicationSettingConfigurationDto> GetSettingConfigAsync()
         {
+            Logger.LogDebug("Executing AbpApplicationConfigurationAppService.GetSettingConfigAsync()");
+
             var result = new ApplicationSettingConfigurationDto
             {
                 Values = new Dictionary<string, string>()
@@ -160,11 +177,15 @@ namespace Volo.Abp.AspNetCore.Mvc.ApplicationConfigurations
                 result.Values[settingDefinition.Name] = await _settingProvider.GetOrNullAsync(settingDefinition.Name);
             }
 
+            Logger.LogDebug("Executed AbpApplicationConfigurationAppService.GetSettingConfigAsync()");
+
             return result;
         }
 
         protected virtual async Task<ApplicationFeatureConfigurationDto> GetFeaturesConfigAsync()
         {
+            Logger.LogDebug("Executing AbpApplicationConfigurationAppService.GetFeaturesConfigAsync()");
+
             var result = new ApplicationFeatureConfigurationDto();
 
             foreach (var featureDefinition in _featureDefinitionManager.GetAll())
@@ -177,6 +198,8 @@ namespace Volo.Abp.AspNetCore.Mvc.ApplicationConfigurations
                 result.Values[featureDefinition.Name] = await FeatureChecker.GetOrNullAsync(featureDefinition.Name);
             }
 
+            Logger.LogDebug("Executed AbpApplicationConfigurationAppService.GetFeaturesConfigAsync()");
+
             return result;
         }
     }

framework/src/Volo.Abp.AspNetCore.Mvc/Volo/Abp/AspNetCore/Mvc/ApplicationConfigurations/AbpApplicationConfigurationScriptController.cs

@@ -2,6 +2,7 @@
 using System.Text;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
 using Volo.Abp.Auditing;
 using Volo.Abp.Http;
 using Volo.Abp.Json;
@@ -28,12 +29,15 @@ namespace Volo.Abp.AspNetCore.Mvc.ApplicationConfigurations
         [Produces(MimeTypes.Application.Javascript, MimeTypes.Text.Plain)]
         public async Task<ActionResult> Get()
         {
-            return Content(
-                CreateAbpExtendScript(
-                    await _configurationAppService.GetAsync()
-                ),
-                MimeTypes.Application.Javascript
+            Logger.LogDebug("Executing AbpApplicationConfigurationScriptController.Get()");
+
+            var result = CreateAbpExtendScript(
+                await _configurationAppService.GetAsync()
             );
+
+            Logger.LogDebug("Executed AbpApplicationConfigurationScriptController.Get()");
+            
+            return Content(result, MimeTypes.Application.Javascript);
         }
 
         private string CreateAbpExtendScript(ApplicationConfigurationDto config)

framework/src/Volo.Abp.AspNetCore/Microsoft/AspNetCore/RequestLocalization/AbpRequestLocalizationMiddleware.cs

@@ -25,7 +25,9 @@ namespace Microsoft.AspNetCore.RequestLocalization
         {
             var middleware = new RequestLocalizationMiddleware(
                 next,
-                new OptionsWrapper<RequestLocalizationOptions>(_requestLocalizationOptionsProvider.GetLocalizationOptions()),
+                new OptionsWrapper<RequestLocalizationOptions>(
+                    await _requestLocalizationOptionsProvider.GetLocalizationOptionsAsync()
+                ),
                 _loggerFactory
             );
 

framework/src/Volo.Abp.AspNetCore/Microsoft/AspNetCore/RequestLocalization/DefaultAbpRequestLocalizationOptionsProvider.cs

@@ -2,67 +2,76 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Localization;
 using Microsoft.Extensions.DependencyInjection;
+using Nito.AsyncEx;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Localization;
 using Volo.Abp.Settings;
-using Volo.Abp.Threading;
 
 namespace Microsoft.AspNetCore.RequestLocalization
 {
     public class DefaultAbpRequestLocalizationOptionsProvider : IAbpRequestLocalizationOptionsProvider, ISingletonDependency
     {
-        private readonly IServiceProvider _serviceProvider;
-        private Lazy<RequestLocalizationOptions> _lazyRequestLocalizationOptions;
+        private readonly IServiceScopeFactory _serviceProviderFactory;
+        private readonly SemaphoreSlim _syncSemaphore;
+        private Action<RequestLocalizationOptions> _optionsAction;
+        private RequestLocalizationOptions _requestLocalizationOptions;
 
-        public DefaultAbpRequestLocalizationOptionsProvider(IServiceProvider serviceProvider)
+        public DefaultAbpRequestLocalizationOptionsProvider(IServiceScopeFactory serviceProviderFactory)
         {
-            _serviceProvider = serviceProvider;
+            _serviceProviderFactory = serviceProviderFactory;
+            _syncSemaphore = new SemaphoreSlim(1, 1);
         }
 
         public void InitLocalizationOptions(Action<RequestLocalizationOptions> optionsAction = null)
         {
-            _lazyRequestLocalizationOptions = new Lazy<RequestLocalizationOptions>(() =>
+            _optionsAction = optionsAction;
+        }
+
+        public async Task<RequestLocalizationOptions> GetLocalizationOptionsAsync()
+        {
+            if (_requestLocalizationOptions == null)
             {
-                using (var serviceScope = _serviceProvider.CreateScope())
+                using (await _syncSemaphore.LockAsync())
                 {
-                    var languageProvider = serviceScope.ServiceProvider.GetRequiredService<ILanguageProvider>();
-                    var settingProvider = serviceScope.ServiceProvider.GetRequiredService<ISettingProvider>();
+                    using (var serviceScope = _serviceProviderFactory.CreateScope())
+                    {
+                        var languageProvider = serviceScope.ServiceProvider.GetRequiredService<ILanguageProvider>();
+                        var settingProvider = serviceScope.ServiceProvider.GetRequiredService<ISettingProvider>();
 
-                    var languages = AsyncHelper.RunSync(languageProvider.GetLanguagesAsync);
-                    var defaultLanguage = AsyncHelper.RunSync(() =>
-                        settingProvider.GetOrNullAsync(LocalizationSettingNames.DefaultLanguage));
+                        var languages = await languageProvider.GetLanguagesAsync();
+                        var defaultLanguage = await settingProvider.GetOrNullAsync(LocalizationSettingNames.DefaultLanguage);
 
-                    var options = !languages.Any()
-                        ? new RequestLocalizationOptions()
-                        : new RequestLocalizationOptions
-                        {
-                            DefaultRequestCulture = DefaultGetRequestCulture(defaultLanguage, languages),
+                        var options = !languages.Any()
+                            ? new RequestLocalizationOptions()
+                            : new RequestLocalizationOptions
+                            {
+                                DefaultRequestCulture = DefaultGetRequestCulture(defaultLanguage, languages),
 
-                            SupportedCultures = languages
-                                .Select(l => l.CultureName)
-                                .Distinct()
-                                .Select(c => new CultureInfo(c))
-                                .ToArray(),
+                                SupportedCultures = languages
+                                    .Select(l => l.CultureName)
+                                    .Distinct()
+                                    .Select(c => new CultureInfo(c))
+                                    .ToArray(),
 
-                            SupportedUICultures = languages
-                                .Select(l => l.UiCultureName)
-                                .Distinct()
-                                .Select(c => new CultureInfo(c))
-                                .ToArray()
-                        };
+                                SupportedUICultures = languages
+                                    .Select(l => l.UiCultureName)
+                                    .Distinct()
+                                    .Select(c => new CultureInfo(c))
+                                    .ToArray()
+                            };
 
-                    optionsAction?.Invoke(options);
-                    return options;
+                        _optionsAction?.Invoke(options);
+                        _requestLocalizationOptions = options;
+                    }
                 }
-            }, true);
-        }
+            }
 
-        public RequestLocalizationOptions GetLocalizationOptions()
-        {
-            return _lazyRequestLocalizationOptions.Value;
+            return _requestLocalizationOptions;
         }
 
         private static RequestCulture DefaultGetRequestCulture(string defaultLanguage, IReadOnlyList<LanguageInfo> languages)

framework/src/Volo.Abp.AspNetCore/Microsoft/AspNetCore/RequestLocalization/IAbpRequestLocalizationOptionsProvider.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading.Tasks;
 using Microsoft.AspNetCore.Builder;
 
 namespace Microsoft.AspNetCore.RequestLocalization
@@ -7,6 +8,6 @@ namespace Microsoft.AspNetCore.RequestLocalization
     {
         void InitLocalizationOptions(Action<RequestLocalizationOptions> optionsAction = null);
 
-        RequestLocalizationOptions GetLocalizationOptions();
+        Task<RequestLocalizationOptions> GetLocalizationOptionsAsync();
     }
 }

framework/src/Volo.Abp.Authorization/Microsoft/AspNetCore/Authorization/AbpAuthorizationServiceExtensions.cs

@@ -7,52 +7,54 @@ namespace Microsoft.AspNetCore.Authorization
 {
     public static class AbpAuthorizationServiceExtensions
     {
-        public static Task<AuthorizationResult> AuthorizeAsync(this IAuthorizationService authorizationService, string policyName)
+        public static async Task<AuthorizationResult> AuthorizeAsync(this IAuthorizationService authorizationService, string policyName)
         {
-            return AuthorizeAsync(
+            return await AuthorizeAsync(
                 authorizationService,
-                authorizationService.AsAbpAuthorizationService().CurrentPrincipal,
+                null,
                 policyName
             );
         }
 
-        public static Task<AuthorizationResult> AuthorizeAsync(this IAuthorizationService authorizationService, object resource, IAuthorizationRequirement requirement)
+        public static async Task<AuthorizationResult> AuthorizeAsync(this IAuthorizationService authorizationService, object resource, IAuthorizationRequirement requirement)
         {
-            return authorizationService.AuthorizeAsync(
+            return await authorizationService.AuthorizeAsync(
                 authorizationService.AsAbpAuthorizationService().CurrentPrincipal,
                 resource,
                 requirement
             );
         }
 
-        public static Task<AuthorizationResult> AuthorizeAsync(this IAuthorizationService authorizationService, object resource, AuthorizationPolicy policy)
+        public static async Task<AuthorizationResult> AuthorizeAsync(this IAuthorizationService authorizationService, object resource, AuthorizationPolicy policy)
         {
-            return authorizationService.AuthorizeAsync(
+            return await authorizationService.AuthorizeAsync(
                 authorizationService.AsAbpAuthorizationService().CurrentPrincipal,
                 resource,
                 policy
             );
         }
 
-        public static Task<AuthorizationResult> AuthorizeAsync(this IAuthorizationService authorizationService, AuthorizationPolicy policy)
+        public static async Task<AuthorizationResult> AuthorizeAsync(this IAuthorizationService authorizationService, AuthorizationPolicy policy)
         {
-            return AuthorizeAsync(authorizationService, authorizationService.AsAbpAuthorizationService().CurrentPrincipal,
+            return await AuthorizeAsync(
+                authorizationService, 
+                null,
                 policy
             );
         }
 
-        public static Task<AuthorizationResult> AuthorizeAsync(this IAuthorizationService authorizationService, object resource, IEnumerable<IAuthorizationRequirement> requirements)
+        public static async Task<AuthorizationResult> AuthorizeAsync(this IAuthorizationService authorizationService, object resource, IEnumerable<IAuthorizationRequirement> requirements)
         {
-            return authorizationService.AuthorizeAsync(
+            return await authorizationService.AuthorizeAsync(
                 authorizationService.AsAbpAuthorizationService().CurrentPrincipal,
                 resource,
                 requirements
             );
         }
 
-        public static Task<AuthorizationResult> AuthorizeAsync(this IAuthorizationService authorizationService, object resource, string policyName)
+        public static async Task<AuthorizationResult> AuthorizeAsync(this IAuthorizationService authorizationService, object resource, string policyName)
         {
-            return authorizationService.AuthorizeAsync(
+            return await authorizationService.AuthorizeAsync(
                 authorizationService.AsAbpAuthorizationService().CurrentPrincipal,
                 resource,
                 policyName

framework/src/Volo.Abp.BackgroundJobs.RabbitMQ/Volo/Abp/BackgroundJobs/RabbitMQ/IJobQueueManager.cs

@@ -1,9 +1,10 @@
-using Volo.Abp.Threading;
+using System.Threading.Tasks;
+using Volo.Abp.Threading;
 
 namespace Volo.Abp.BackgroundJobs.RabbitMQ
 {
     public interface IJobQueueManager : IRunnable
     {
-        IJobQueue<TArgs> Get<TArgs>();
+        Task<IJobQueue<TArgs>> GetAsync<TArgs>();
     }
 }

framework/src/Volo.Abp.BackgroundJobs.RabbitMQ/Volo/Abp/BackgroundJobs/RabbitMQ/JobQueueManager.cs

@@ -4,6 +4,7 @@ using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
+using Nito.AsyncEx;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Threading;
 
@@ -17,6 +18,8 @@ namespace Volo.Abp.BackgroundJobs.RabbitMQ
 
         protected AbpBackgroundJobOptions Options { get; }
 
+        protected SemaphoreSlim SyncSemaphore { get; }
+
         public JobQueueManager(
             IOptions<AbpBackgroundJobOptions> options,
             IServiceProvider serviceProvider)
@@ -24,6 +27,7 @@ namespace Volo.Abp.BackgroundJobs.RabbitMQ
             ServiceProvider = serviceProvider;
             Options = options.Value;
             JobQueues = new ConcurrentDictionary<string, IRunnable>();
+            SyncSemaphore = new SemaphoreSlim(1, 1);
         }
 
         public async Task StartAsync(CancellationToken cancellationToken = default)
@@ -51,20 +55,31 @@ namespace Volo.Abp.BackgroundJobs.RabbitMQ
             JobQueues.Clear();
         }
 
-        public IJobQueue<TArgs> Get<TArgs>()
+        public async Task<IJobQueue<TArgs>> GetAsync<TArgs>()
         {
             var jobConfiguration = Options.GetJob(typeof(TArgs));
 
-            return (IJobQueue<TArgs>)JobQueues.GetOrAdd(jobConfiguration.JobName, _ =>
+            if (JobQueues.TryGetValue(jobConfiguration.JobName, out var jobQueue))
+            {
+                return (IJobQueue<TArgs>)jobQueue;
+            }
+
+            using (await SyncSemaphore.LockAsync())
             {
-                var jobQueue = (IRunnable) ServiceProvider
-                    .GetRequiredService(typeof(IJobQueue<>)
-                        .MakeGenericType(typeof(TArgs)));
+                if (JobQueues.TryGetValue(jobConfiguration.JobName, out jobQueue))
+                {
+                    return (IJobQueue<TArgs>)jobQueue;
+                }
 
-                AsyncHelper.RunSync(() => jobQueue.StartAsync());
+                jobQueue = (IJobQueue<TArgs>)ServiceProvider
+                    .GetRequiredService(typeof(IJobQueue<>).MakeGenericType(typeof(TArgs)));
 
-                return jobQueue;
-            });
+                await jobQueue.StartAsync();
+
+                JobQueues.TryAdd(jobConfiguration.JobName, jobQueue);
+
+                return (IJobQueue<TArgs>)jobQueue;
+            }
         }
     }
 }

framework/src/Volo.Abp.BackgroundJobs.RabbitMQ/Volo/Abp/BackgroundJobs/RabbitMQ/RabbitMqBackgroundJobManager.cs

@@ -14,14 +14,13 @@ namespace Volo.Abp.BackgroundJobs.RabbitMQ
             _jobQueueManager = jobQueueManager;
         }
 
-        public Task<string> EnqueueAsync<TArgs>(
+        public async Task<string> EnqueueAsync<TArgs>(
             TArgs args, 
             BackgroundJobPriority priority = BackgroundJobPriority.Normal,
             TimeSpan? delay = null)
         {
-            return _jobQueueManager
-                .Get<TArgs>()
-                .EnqueueAsync(args, priority, delay);
+            var jobQueue = await _jobQueueManager.GetAsync<TArgs>();
+            return await jobQueue.EnqueueAsync(args, priority, delay);
         }
     }
 }

framework/src/Volo.Abp.Localization/Volo/Abp/Localization/AbpDictionaryBasedStringLocalizer.cs

@@ -31,8 +31,7 @@ namespace Volo.Abp.Localization
                 includeParentCultures
             );
         }
-
-
+        
         public IEnumerable<LocalizedString> GetAllStrings(bool includeParentCultures, bool includeBaseLocalizers)
         {
             return GetAllStrings(

modules/docs/src/Volo.Docs.HttpApi/Volo/Docs/Documents/DocsDocumentController.cs

@@ -46,6 +46,8 @@ namespace Volo.Docs.Documents
             return DocumentAppService.GetResourceAsync(input);
         }
 
+        [HttpGet]
+        [Route("parameters")]
         public Task<DocumentParametersDto> GetParametersAsync(GetParametersDocumentInput input)
         {
             return DocumentAppService.GetParametersAsync(input);

modules/docs/src/Volo.Docs.Web/Pages/Documents/Project/Index.cshtml.cs

@@ -5,9 +5,11 @@ using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Rendering;
+using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Volo.Abp.AspNetCore.Mvc.Localization;
 using Volo.Abp.AspNetCore.Mvc.UI.RazorPages;
+using Volo.Abp.Domain.Entities;
 using Volo.Abp.Localization;
 using Volo.Docs.Documents;
 using Volo.Docs.HtmlConverting;
@@ -87,7 +89,15 @@ namespace Volo.Docs.Pages.Documents.Project
             DocumentsUrlPrefix = _uiOptions.RoutePrefix;
             ShowProjectsCombobox = _uiOptions.ShowProjectsCombobox;
 
-            await SetProjectAsync();
+            try
+            {
+                await SetProjectAsync();    
+            }
+            catch (EntityNotFoundException e)
+            {
+                Logger.LogWarning(e.Message);
+                return NotFound();
+            }
 
             if (ShowProjectsCombobox)
             {

modules/identity/src/Volo.Abp.Identity.Domain/Volo/Abp/Identity/IdentityUser.cs

@@ -130,16 +130,17 @@ namespace Volo.Abp.Identity
             ExtraProperties = new Dictionary<string, object>();
         }
 
-        public IdentityUser(Guid id, [NotNull] string userName, string email = null, Guid? tenantId = null)
+        public IdentityUser(Guid id, [NotNull] string userName, [NotNull] string email, Guid? tenantId = null)
         {
             Check.NotNull(userName, nameof(userName));
+            Check.NotNull(email, nameof(email));
 
             Id = id;
             TenantId = tenantId;
             UserName = userName;
             NormalizedUserName = userName.ToUpperInvariant();
             Email = email;
-            NormalizedEmail = email?.ToUpperInvariant();
+            NormalizedEmail = email.ToUpperInvariant();
             ConcurrencyStamp = Guid.NewGuid().ToString();
             SecurityStamp = Guid.NewGuid().ToString();
 

modules/identity/src/Volo.Abp.Identity.Domain/Volo/Abp/Identity/IdentityUserStore.cs

@@ -597,11 +597,12 @@ namespace Volo.Abp.Identity
         /// <param name="email">The email to set.</param>
         /// <param name="cancellationToken">The <see cref="CancellationToken"/> used to propagate notifications that the operation should be canceled.</param>
         /// <returns>The task object representing the asynchronous operation.</returns>
-        public virtual Task SetEmailAsync([NotNull] IdentityUser user, string email, CancellationToken cancellationToken = default)
+        public virtual Task SetEmailAsync([NotNull] IdentityUser user, [NotNull]  string email, CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
 
             Check.NotNull(user, nameof(user));
+            Check.NotNull(email, nameof(email));
 
             user.Email = email;
 

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

@@ -29,7 +29,7 @@ namespace Volo.Abp.Identity.EntityFrameworkCore
                 b.ConfigureAbpUser();
 
                 b.Property(u => u.NormalizedUserName).IsRequired().HasMaxLength(IdentityUserConsts.MaxNormalizedUserNameLength).HasColumnName(nameof(IdentityUser.NormalizedUserName));
-                b.Property(u => u.NormalizedEmail).HasMaxLength(IdentityUserConsts.MaxNormalizedEmailLength).HasColumnName(nameof(IdentityUser.NormalizedEmail));
+                b.Property(u => u.NormalizedEmail).IsRequired().HasMaxLength(IdentityUserConsts.MaxNormalizedEmailLength).HasColumnName(nameof(IdentityUser.NormalizedEmail));
                 b.Property(u => u.PasswordHash).HasMaxLength(IdentityUserConsts.MaxPasswordHashLength).HasColumnName(nameof(IdentityUser.PasswordHash));
                 b.Property(u => u.SecurityStamp).IsRequired().HasMaxLength(IdentityUserConsts.MaxSecurityStampLength).HasColumnName(nameof(IdentityUser.SecurityStamp));
                 b.Property(u => u.TwoFactorEnabled).HasDefaultValue(false).HasColumnName(nameof(IdentityUser.TwoFactorEnabled));

modules/users/src/Volo.Abp.Users.EntityFrameworkCore/Volo/Abp/Users/EntityFrameworkCore/AbpUsersDbContextModelCreatingExtensions.cs

@@ -10,7 +10,7 @@ namespace Volo.Abp.Users.EntityFrameworkCore
         {
             b.Property(u => u.TenantId).HasColumnName(nameof(IUser.TenantId));
             b.Property(u => u.UserName).IsRequired().HasMaxLength(AbpUserConsts.MaxUserNameLength).HasColumnName(nameof(IUser.UserName));
-            b.Property(u => u.Email).HasMaxLength(AbpUserConsts.MaxEmailLength).HasColumnName(nameof(IUser.Email));
+            b.Property(u => u.Email).IsRequired().HasMaxLength(AbpUserConsts.MaxEmailLength).HasColumnName(nameof(IUser.Email));
             b.Property(u => u.Name).HasMaxLength(AbpUserConsts.MaxNameLength).HasColumnName(nameof(IUser.Name));
             b.Property(u => u.Surname).HasMaxLength(AbpUserConsts.MaxSurnameLength).HasColumnName(nameof(IUser.Surname));
             b.Property(u => u.EmailConfirmed).HasDefaultValue(false).HasColumnName(nameof(IUser.EmailConfirmed));

templates/app/aspnet-core/src/MyCompanyName.MyProjectName.EntityFrameworkCore.DbMigrations/Migrations/20191022082740_Initial.Designer.cs → templates/app/aspnet-core/src/MyCompanyName.MyProjectName.EntityFrameworkCore.DbMigrations/Migrations/20191218090017_Initial.Designer.cs

@@ -10,14 +10,14 @@ using MyCompanyName.MyProjectName.EntityFrameworkCore;
 namespace MyCompanyName.MyProjectName.Migrations
 {
     [DbContext(typeof(MyProjectNameMigrationsDbContext))]
-    [Migration("20191022082740_Initial")]
+    [Migration("20191218090017_Initial")]
     partial class Initial
     {
         protected override void BuildTargetModel(ModelBuilder modelBuilder)
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "3.0.0")
+                .HasAnnotation("ProductVersion", "3.1.0")
                 .HasAnnotation("Relational:MaxIdentifierLength", 128)
                 .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
 
@@ -512,6 +512,7 @@ namespace MyCompanyName.MyProjectName.Migrations
                         .HasColumnType("datetime2");
 
                     b.Property<string>("Email")
+                        .IsRequired()
                         .HasColumnName("Email")
                         .HasColumnType("nvarchar(256)")
                         .HasMaxLength(256);
@@ -555,6 +556,7 @@ namespace MyCompanyName.MyProjectName.Migrations
                         .HasMaxLength(64);
 
                     b.Property<string>("NormalizedEmail")
+                        .IsRequired()
                         .HasColumnName("NormalizedEmail")
                         .HasColumnType("nvarchar(256)")
                         .HasMaxLength(256);

templates/app/aspnet-core/src/MyCompanyName.MyProjectName.EntityFrameworkCore.DbMigrations/Migrations/20191022082740_Initial.cs → templates/app/aspnet-core/src/MyCompanyName.MyProjectName.EntityFrameworkCore.DbMigrations/Migrations/20191218090017_Initial.cs

@@ -184,8 +184,8 @@ namespace MyCompanyName.MyProjectName.Migrations
                     NormalizedUserName = table.Column<string>(maxLength: 256, nullable: false),
                     Name = table.Column<string>(maxLength: 64, nullable: true),
                     Surname = table.Column<string>(maxLength: 64, nullable: true),
-                    Email = table.Column<string>(maxLength: 256, nullable: true),
-                    NormalizedEmail = table.Column<string>(maxLength: 256, nullable: true),
+                    Email = table.Column<string>(maxLength: 256, nullable: false),
+                    NormalizedEmail = table.Column<string>(maxLength: 256, nullable: false),
                     EmailConfirmed = table.Column<bool>(nullable: false, defaultValue: false),
                     PasswordHash = table.Column<string>(maxLength: 256, nullable: true),
                     SecurityStamp = table.Column<string>(maxLength: 256, nullable: false),

templates/app/aspnet-core/src/MyCompanyName.MyProjectName.EntityFrameworkCore.DbMigrations/Migrations/MyProjectNameMigrationsDbContextModelSnapshot.cs

@@ -15,7 +15,7 @@ namespace MyCompanyName.MyProjectName.Migrations
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "3.0.0")
+                .HasAnnotation("ProductVersion", "3.1.0")
                 .HasAnnotation("Relational:MaxIdentifierLength", 128)
                 .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
 
@@ -510,6 +510,7 @@ namespace MyCompanyName.MyProjectName.Migrations
                         .HasColumnType("datetime2");
 
                     b.Property<string>("Email")
+                        .IsRequired()
                         .HasColumnName("Email")
                         .HasColumnType("nvarchar(256)")
                         .HasMaxLength(256);
@@ -553,6 +554,7 @@ namespace MyCompanyName.MyProjectName.Migrations
                         .HasMaxLength(64);
 
                     b.Property<string>("NormalizedEmail")
+                        .IsRequired()
                         .HasColumnName("NormalizedEmail")
                         .HasColumnType("nvarchar(256)")
                         .HasMaxLength(256);

templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Web.Unified/Migrations/20191127123650_Initial.Designer.cs → templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Web.Unified/Migrations/20191218090727_Initial.Designer.cs

@@ -10,14 +10,14 @@ using MyCompanyName.MyProjectName.EntityFrameworkCore;
 namespace MyCompanyName.MyProjectName.Migrations
 {
     [DbContext(typeof(UnifiedDbContext))]
-    [Migration("20191127123650_Initial")]
+    [Migration("20191218090727_Initial")]
     partial class Initial
     {
         protected override void BuildTargetModel(ModelBuilder modelBuilder)
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "3.0.0")
+                .HasAnnotation("ProductVersion", "3.1.0")
                 .HasAnnotation("Relational:MaxIdentifierLength", 128)
                 .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
 
@@ -426,6 +426,7 @@ namespace MyCompanyName.MyProjectName.Migrations
                         .HasColumnType("datetime2");
 
                     b.Property<string>("Email")
+                        .IsRequired()
                         .HasColumnName("Email")
                         .HasColumnType("nvarchar(256)")
                         .HasMaxLength(256);
@@ -469,6 +470,7 @@ namespace MyCompanyName.MyProjectName.Migrations
                         .HasMaxLength(64);
 
                     b.Property<string>("NormalizedEmail")
+                        .IsRequired()
                         .HasColumnName("NormalizedEmail")
                         .HasColumnType("nvarchar(256)")
                         .HasMaxLength(256);

templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Web.Unified/Migrations/20191127123650_Initial.cs → templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Web.Unified/Migrations/20191218090727_Initial.cs

@@ -148,8 +148,8 @@ namespace MyCompanyName.MyProjectName.Migrations
                     NormalizedUserName = table.Column<string>(maxLength: 256, nullable: false),
                     Name = table.Column<string>(maxLength: 64, nullable: true),
                     Surname = table.Column<string>(maxLength: 64, nullable: true),
-                    Email = table.Column<string>(maxLength: 256, nullable: true),
-                    NormalizedEmail = table.Column<string>(maxLength: 256, nullable: true),
+                    Email = table.Column<string>(maxLength: 256, nullable: false),
+                    NormalizedEmail = table.Column<string>(maxLength: 256, nullable: false),
                     EmailConfirmed = table.Column<bool>(nullable: false, defaultValue: false),
                     PasswordHash = table.Column<string>(maxLength: 256, nullable: true),
                     SecurityStamp = table.Column<string>(maxLength: 256, nullable: false),

templates/module/aspnet-core/host/MyCompanyName.MyProjectName.Web.Unified/Migrations/UnifiedDbContextModelSnapshot.cs

@@ -15,7 +15,7 @@ namespace MyCompanyName.MyProjectName.Migrations
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "3.0.0")
+                .HasAnnotation("ProductVersion", "3.1.0")
                 .HasAnnotation("Relational:MaxIdentifierLength", 128)
                 .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);
 
@@ -424,6 +424,7 @@ namespace MyCompanyName.MyProjectName.Migrations
                         .HasColumnType("datetime2");
 
                     b.Property<string>("Email")
+                        .IsRequired()
                         .HasColumnName("Email")
                         .HasColumnType("nvarchar(256)")
                         .HasMaxLength(256);
@@ -467,6 +468,7 @@ namespace MyCompanyName.MyProjectName.Migrations
                         .HasMaxLength(64);
 
                     b.Property<string>("NormalizedEmail")
+                        .IsRequired()
                         .HasColumnName("NormalizedEmail")
                         .HasColumnType("nvarchar(256)")
                         .HasMaxLength(256);