Refactored VirtualFileTemplateContentContributor

framework/src/Volo.Abp.TextTemplating/Volo/Abp/TextTemplating/VirtualFiles/FolderLocalizedTemplateContentReader.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.Extensions.FileProviders;
+using Volo.Abp.Localization;
+using Volo.Abp.VirtualFileSystem;
+
+namespace Volo.Abp.TextTemplating.VirtualFiles
+{
+    public class FolderLocalizedTemplateContentReader : ILocalizedTemplateContentReader
+    {
+        private Dictionary<string, string> _dictionary;
+
+        public async Task ReadContentsAsync(IVirtualFileProvider virtualFileProvider, string virtualPath)
+        {
+            _dictionary = new Dictionary<string, string>();
+
+            var directoryInfo = virtualFileProvider.GetFileInfo(virtualPath);
+            if (!directoryInfo.IsDirectory)
+            {
+                throw new AbpException("Given virtual path is not a folder: " + virtualPath);
+            }
+
+            foreach (var file in virtualFileProvider.GetDirectoryContents(virtualPath))
+            {
+                if (file.IsDirectory)
+                {
+                    continue;
+                }
+
+                _dictionary.Add(file.Name.RemovePostFix(".tpl"), await file.ReadAsStringAsync());
+            }
+        }
+
+        public string GetContent(string cultureName, string defaultCultureName)
+        {
+            var content = _dictionary.GetOrDefault(cultureName);
+            if (content != null)
+            {
+                return content;
+            }
+
+            if (cultureName.Contains("-"))
+            {
+                var baseCultureName = CultureHelper.GetBaseCultureName(cultureName);
+                content = _dictionary.GetOrDefault(baseCultureName);
+                if (content != null)
+                {
+                    return content;
+                }
+            }
+
+            if (defaultCultureName != null)
+            {
+                content = _dictionary.GetOrDefault(defaultCultureName);
+                if (content != null)
+                {
+                    return content;
+                }
+            }
+
+            return null;
+        }
+    }
+}

framework/src/Volo.Abp.TextTemplating/Volo/Abp/TextTemplating/VirtualFiles/ILocalizedTemplateContentReader.cs

@@ -0,0 +1,7 @@
+namespace Volo.Abp.TextTemplating.VirtualFiles
+{
+    public interface ILocalizedTemplateContentReader
+    {
+        public string GetContent(string culture, string defaultCultureName = null);
+    }
+}

framework/src/Volo.Abp.TextTemplating/Volo/Abp/TextTemplating/VirtualFiles/NullLocalizedTemplateContentReader.cs

@@ -0,0 +1,19 @@
+namespace Volo.Abp.TextTemplating.VirtualFiles
+{
+    public class NullLocalizedTemplateContentReader : ILocalizedTemplateContentReader
+    {
+        public static NullLocalizedTemplateContentReader Instance { get; } = new NullLocalizedTemplateContentReader();
+
+        private NullLocalizedTemplateContentReader()
+        {
+            
+        }
+
+        public string GetContent(
+            string culture,
+            string defaultCultureName = null)
+        {
+            return null;
+        }
+    }
+}

framework/src/Volo.Abp.TextTemplating/Volo/Abp/TextTemplating/VirtualFiles/SingleFileLocalizedTemplateContentReader.cs

@@ -0,0 +1,20 @@
+using System.Threading.Tasks;
+using Microsoft.Extensions.FileProviders;
+
+namespace Volo.Abp.TextTemplating.VirtualFiles
+{
+    public class SingleFileLocalizedTemplateContentReader : ILocalizedTemplateContentReader
+    {
+        private string _content;
+
+        public async Task ReadContentsAsync(IFileInfo fileInfo)
+        {
+            _content = await fileInfo.ReadAsStringAsync();
+        }
+
+        public string GetContent(string culture, string defaultCultureName)
+        {
+            return _content;
+        }
+    }
+}

framework/src/Volo.Abp.TextTemplating/Volo/Abp/TextTemplating/VirtualFiles/VirtualFileTemplateContentContributor.cs

@@ -1,10 +1,7 @@
-using System;
+using System.Collections.Generic;
-using System.Collections.Generic;
 using System.Globalization;
 using System.Threading.Tasks;
-using Microsoft.Extensions.FileProviders;
 using Volo.Abp.DependencyInjection;
-using Volo.Abp.Localization;
 using Volo.Abp.VirtualFileSystem;
 
 namespace Volo.Abp.TextTemplating.VirtualFiles
@@ -20,74 +17,50 @@ namespace Volo.Abp.TextTemplating.VirtualFiles
             _virtualFileProvider = virtualFileProvider;
         }
 
-        public async Task<string> GetOrNullAsync(TemplateContentContributorContext context)
+        public virtual async Task<string> GetOrNullAsync(TemplateContentContributorContext context)
         {
-            var virtualPath = context.TemplateDefinition.Properties.GetOrDefault(VirtualPathPropertyName) as string;
-            if (virtualPath == null)
-            {
-                return null;
-            }
-
-            //TODO: Refactor: Split implementation based on single file or dictionary of culture-specific contents
-
             var cultureName = context.Culture ??
                               CultureInfo.CurrentUICulture.Name;
 
-            var dictionary = GetTemplateDictionary(virtualPath);
+            var localizedReader = await CreateLocalizedReader(context);
 
-            var content = dictionary.GetOrDefault(cultureName);
+            return localizedReader.GetContent(
-            if (content != null)
+                cultureName,
-            {
+                context.TemplateDefinition.DefaultCultureName
-                return content;
+            );
-            }
+        }
+
+        protected async Task<ILocalizedTemplateContentReader> CreateLocalizedReader(
+            TemplateContentContributorContext context)
+        {
+            var virtualPath = context
+                .TemplateDefinition
+                .Properties
+                .GetOrDefault(VirtualPathPropertyName) as string;
 
-            if (cultureName.Contains("-"))
+            if (virtualPath == null)
             {
-                var baseCultureName = CultureHelper.GetBaseCultureName(cultureName);
+                return NullLocalizedTemplateContentReader.Instance;
-                content = dictionary.GetOrDefault(baseCultureName);
-                if (content != null)
-                {
-                    return content;
-                }
             }
 
-            if (context.TemplateDefinition.DefaultCultureName != null)
+            var fileInfo = _virtualFileProvider.GetFileInfo(virtualPath);
+            if (!fileInfo.Exists)
             {
-                content = dictionary.GetOrDefault(context.TemplateDefinition.DefaultCultureName);
+                throw new AbpException("Could not find a file/folder at the location: " + virtualPath);
-                if (content != null)
-                {
-                    return content;
-                }
             }
 
-            return dictionary.GetOrDefault("__default");
+            if (fileInfo.IsDirectory)
-        }
-
-        private Dictionary<string, string> GetTemplateDictionary(string virtualPath)
-        {
-            var dictionary = new Dictionary<string, string>();
-
-            var fileInfo = _virtualFileProvider.GetFileInfo(virtualPath);
-            if (!fileInfo.IsDirectory)
             {
-                //TODO: __default to consts
+                var folderReader = new FolderLocalizedTemplateContentReader();
-                dictionary.Add("__default", fileInfo.ReadAsString());
+                await folderReader.ReadContentsAsync(_virtualFileProvider, virtualPath);
+                return folderReader;
             }
-            else
+            else //File
             {
-                foreach (var file in _virtualFileProvider.GetDirectoryContents(virtualPath))
+                var singleFileReader = new SingleFileLocalizedTemplateContentReader();
-                {
+                await singleFileReader.ReadContentsAsync(fileInfo);
-                    if (file.IsDirectory)
+                return singleFileReader;
-                    {
-                        continue;
-                    }
-
-                    // TODO: How to normalize file names?
-                    dictionary.Add(file.Name.RemovePostFix(".tpl"), file.ReadAsString());
-                }
             }
-
-            return dictionary;
         }
     }
 }

framework/src/Volo.Abp.VirtualFileSystem/Microsoft/Extensions/FileProviders/AbpFileInfoExtensions.cs

@@ -18,6 +18,14 @@ namespace Microsoft.Extensions.FileProviders
             return fileInfo.ReadAsString(Encoding.UTF8);
         }
 
+        /// <summary>
+        /// Reads file content as string using <see cref="Encoding.UTF8"/> encoding.
+        /// </summary>
+        public static Task<string> ReadAsStringAsync([NotNull] this IFileInfo fileInfo)
+        {
+            return fileInfo.ReadAsStringAsync(Encoding.UTF8);
+        }
+
         /// <summary>
         /// Reads file content as string using the given <paramref name="encoding"/>.
         /// </summary>
@@ -34,6 +42,22 @@ namespace Microsoft.Extensions.FileProviders
             }
         }
 
+        /// <summary>
+        /// Reads file content as string using the given <paramref name="encoding"/>.
+        /// </summary>
+        public static async Task<string> ReadAsStringAsync([NotNull] this IFileInfo fileInfo, Encoding encoding)
+        {
+            Check.NotNull(fileInfo, nameof(fileInfo));
+
+            using (var stream = fileInfo.CreateReadStream())
+            {
+                using (var streamReader = new StreamReader(stream, encoding, true))
+                {
+                    return await streamReader.ReadToEndAsync();
+                }
+            }
+        }
+
         /// <summary>
         /// Reads file content as byte[].
         /// </summary>