Introduce IStringLocalizer.GetAllStrings and overloads.

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

@@ -56,6 +56,20 @@ public class RemoteLocalizationContributor : ILocalizationResourceContributor
         }
     }
 
+    public async Task FillAsync(string cultureName, Dictionary<string, LocalizedString> dictionary)
+    {
+        var resource = await GetResourceOrNullAsync();
+        if (resource == null)
+        {
+            return;
+        }
+
+        foreach (var keyValue in resource)
+        {
+            dictionary[keyValue.Key] = new LocalizedString(keyValue.Key, keyValue.Value);
+        }
+    }
+
     public Task<IEnumerable<string>> GetSupportedCulturesAsync()
     {
         /* This contributor does not know all the supported cultures by the
@@ -78,4 +92,20 @@ public class RemoteLocalizationContributor : ILocalizationResourceContributor
 
         return resource;
     }
+    
+    private async Task<Dictionary<string, string>> GetResourceOrNullAsync()
+    {
+        var applicationConfigurationDto = await _applicationConfigurationClient.GetAsync();
+
+        var resource = applicationConfigurationDto
+            .Localization.Values
+            .GetOrDefault(_resource.ResourceName);
+
+        if (resource == null)
+        {
+            _logger.LogWarning($"Could not find the localization resource {_resource.ResourceName} on the remote server!");
+        }
+
+        return resource;
+    }
 }

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

@@ -38,6 +38,14 @@ public class AbpDictionaryBasedStringLocalizer : IAbpStringLocalizer
             includeParentCultures
         );
     }
+    
+    public async Task<IEnumerable<LocalizedString>> GetAllStringsAsync(bool includeParentCultures)
+    {
+        return await GetAllStringsAsync(
+            CultureInfo.CurrentUICulture.Name,
+            includeParentCultures
+        );
+    }
 
     public IEnumerable<LocalizedString> GetAllStrings(
         bool includeParentCultures,
@@ -52,6 +60,19 @@ public class AbpDictionaryBasedStringLocalizer : IAbpStringLocalizer
         );
     }
 
+    public async Task<IEnumerable<LocalizedString>> GetAllStringsAsync(
+        bool includeParentCultures, 
+        bool includeBaseLocalizers,
+        bool includeDynamicContributors)
+    {
+        return await GetAllStringsAsync(
+            CultureInfo.CurrentUICulture.Name,
+            includeParentCultures,
+            includeBaseLocalizers,
+            includeDynamicContributors
+        );
+    }
+
     public Task<IEnumerable<string>> GetSupportedCulturesAsync()
     {
         return Resource.Contributors.GetSupportedCulturesAsync();
@@ -200,6 +221,77 @@ public class AbpDictionaryBasedStringLocalizer : IAbpStringLocalizer
         return allStrings.Values.ToImmutableList();
     }
 
+    protected virtual async Task<IReadOnlyList<LocalizedString>> GetAllStringsAsync(
+        string cultureName,
+        bool includeParentCultures = true,
+        bool includeBaseLocalizers = true,
+        bool includeDynamicContributors = true)
+    {
+        //TODO: Can be optimized (example: if it's already default dictionary, skip overriding)
+
+        var allStrings = new Dictionary<string, LocalizedString>();
+
+        if (includeBaseLocalizers)
+        {
+            foreach (var baseLocalizer in BaseLocalizers.Select(l => l))
+            {
+                using (CultureHelper.Use(CultureInfo.GetCultureInfo(cultureName)))
+                {
+                    //TODO: Try/catch is a workaround here!
+                    try
+                    {
+                        var baseLocalizedString = await baseLocalizer.GetAllStringsAsync(
+                            includeParentCultures,
+                            includeBaseLocalizers, // Always true, I know!
+                            includeDynamicContributors
+                        );
+                        
+                        foreach (var localizedString in baseLocalizedString)
+                        {
+                            allStrings[localizedString.Name] = localizedString;
+                        }
+                    }
+                    catch (MissingManifestResourceException)
+                    {
+
+                    }
+                }
+            }
+        }
+
+        if (includeParentCultures)
+        {
+            //Fill all strings from default culture
+            if (!Resource.DefaultCultureName.IsNullOrEmpty())
+            {
+                await Resource.Contributors.FillAsync(
+                    Resource.DefaultCultureName,
+                    allStrings,
+                    includeDynamicContributors
+                );
+            }
+
+            //Overwrite all strings from the language based on country culture
+            if (cultureName.Contains("-"))
+            {
+                await Resource.Contributors.FillAsync(
+                    CultureHelper.GetBaseCultureName(cultureName),
+                    allStrings,
+                    includeDynamicContributors
+                );
+            }
+        }
+
+        //Overwrite all strings from the original culture
+        await Resource.Contributors.FillAsync(
+            cultureName,
+            allStrings,
+            includeDynamicContributors
+        );
+
+        return allStrings.Values.ToImmutableList();
+    }
+
     public class CultureWrapperStringLocalizer : IAbpStringLocalizer
     {
         private readonly string _cultureName;
@@ -225,6 +317,20 @@ public class AbpDictionaryBasedStringLocalizer : IAbpStringLocalizer
             return _innerLocalizer.GetAllStrings(_cultureName, includeParentCultures, includeBaseLocalizers, includeDynamicContributors);
         }
 
+        public Task<IEnumerable<LocalizedString>> GetAllStringsAsync(bool includeParentCultures)
+        {
+            return _innerLocalizer.GetAllStringsAsync(includeParentCultures);
+        }
+
+        public Task<IEnumerable<LocalizedString>> GetAllStringsAsync(bool includeParentCultures, bool includeBaseLocalizers, bool includeDynamicContributors)
+        {
+            return _innerLocalizer.GetAllStringsAsync(
+                includeParentCultures,
+                includeBaseLocalizers,
+                includeDynamicContributors
+            );
+        }
+
         public Task<IEnumerable<string>> GetSupportedCulturesAsync()
         {
             return _innerLocalizer.GetSupportedCulturesAsync();

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

@@ -58,6 +58,27 @@ public static class AbpStringLocalizerExtensions
             includeParentCultures
         );
     }
+    
+    public static async Task<IEnumerable<LocalizedString>> GetAllStringsAsync(
+        this IStringLocalizer stringLocalizer,
+        bool includeParentCultures,
+        bool includeBaseLocalizers,
+        bool includeDynamicContributors)
+    {
+        var internalLocalizer = ((IStringLocalizer)ProxyHelper.UnProxy(stringLocalizer)).GetInternalLocalizer();
+        if (internalLocalizer is IAbpStringLocalizer abpStringLocalizer)
+        {
+            return await abpStringLocalizer.GetAllStringsAsync(
+                includeParentCultures,
+                includeBaseLocalizers,
+                includeDynamicContributors
+            );
+        }
+
+        return stringLocalizer.GetAllStrings(
+            includeParentCultures
+        );
+    }
 
     public static async Task<IEnumerable<string>> GetSupportedCulturesAsync(this IStringLocalizer localizer)
     {
@@ -69,4 +90,27 @@ public static class AbpStringLocalizerExtensions
 
         return Array.Empty<string>();
     }
+    
+    public static Task<IEnumerable<LocalizedString>> GetAllStringsAsync(
+        this IStringLocalizer localizer)
+    {
+        return localizer.GetAllStringsAsync(includeParentCultures: true);
+    }
+    
+    public static Task<IEnumerable<LocalizedString>> GetAllStringsAsync(
+        this IStringLocalizer localizer,
+        bool includeParentCultures)
+    {
+        Check.NotNull(localizer, nameof(localizer));
+        
+        var internalLocalizer = ((IStringLocalizer)ProxyHelper.UnProxy(localizer)).GetInternalLocalizer();
+        if (internalLocalizer is IAbpStringLocalizer abpStringLocalizer)
+        {
+            return abpStringLocalizer.GetAllStringsAsync(includeParentCultures: includeParentCultures);
+        }
+
+        return Task.FromResult(
+            localizer.GetAllStrings(includeParentCultures: true)
+        );
+    }
 }

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

@@ -12,5 +12,15 @@ public interface IAbpStringLocalizer : IStringLocalizer
         bool includeDynamicContributors
     );
 
+    Task<IEnumerable<LocalizedString>> GetAllStringsAsync(
+        bool includeParentCultures
+    );
+    
+    Task<IEnumerable<LocalizedString>> GetAllStringsAsync(
+        bool includeParentCultures,
+        bool includeBaseLocalizers,
+        bool includeDynamicContributors
+    );
+
     Task<IEnumerable<string>> GetSupportedCulturesAsync();
 }

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

@@ -13,6 +13,8 @@ public interface ILocalizationResourceContributor
     LocalizedString GetOrNull(string cultureName, string name);
 
     void Fill(string cultureName, Dictionary<string, LocalizedString> dictionary);
-    
+
+    Task FillAsync(string cultureName, Dictionary<string, LocalizedString> dictionary);
+
     Task<IEnumerable<string>> GetSupportedCulturesAsync();
 }

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

@@ -44,6 +44,22 @@ public class LocalizationResourceContributorList : List<ILocalizationResourceCon
             contributor.Fill(cultureName, dictionary);
         }
     }
+    
+    public async Task FillAsync(
+        string cultureName, 
+        Dictionary<string, LocalizedString> dictionary,
+        bool includeDynamicContributors = true)
+    {
+        foreach (var contributor in this)
+        {
+            if (!includeDynamicContributors && contributor.IsDynamic)
+            {
+                continue;
+            }
+            
+            await contributor.FillAsync(cultureName, dictionary);
+        }
+    }
 
     internal async Task<IEnumerable<string>> GetSupportedCulturesAsync()
     {

framework/src/Volo.Abp.Localization/Volo/Abp/Localization/VirtualFiles/VirtualFileLocalizationResourceContributorBase.cs

@@ -40,6 +40,12 @@ public abstract class VirtualFileLocalizationResourceContributorBase : ILocaliza
         GetDictionaries().GetOrDefault(cultureName)?.Fill(dictionary);
     }
 
+    public Task FillAsync(string cultureName, Dictionary<string, LocalizedString> dictionary)
+    {
+        Fill(cultureName, dictionary);
+        return Task.CompletedTask;
+    }
+
     public Task<IEnumerable<string>> GetSupportedCulturesAsync()
     {
         return Task.FromResult((IEnumerable<string>)GetDictionaries().Keys);