Add NormalizeContainerName method

framework/src/Volo.Abp.BlobStoring.Aliyun/Volo/Abp/BlobStoring/Aliyun/AliyunBlobProvider.cs

@@ -10,13 +10,16 @@ namespace Volo.Abp.BlobStoring.Aliyun
     {
         protected IOssClientFactory OssClientFactory { get; }
         protected IAliyunBlobNameCalculator AliyunBlobNameCalculator { get; }
+        protected IServiceProvider ServiceProvider { get; }
 
         public AliyunBlobProvider(
             IOssClientFactory ossClientFactory,
-            IAliyunBlobNameCalculator aliyunBlobNameCalculator)
+            IAliyunBlobNameCalculator aliyunBlobNameCalculator,
+            IServiceProvider serviceProvider)
         {
             OssClientFactory = ossClientFactory;
             AliyunBlobNameCalculator = aliyunBlobNameCalculator;
+            ServiceProvider = serviceProvider;
         }
 
         protected virtual IOss GetOssClient(BlobContainerConfiguration blobContainerConfiguration)
@@ -88,15 +91,15 @@ namespace Volo.Abp.BlobStoring.Aliyun
             return memoryStream;
         }
 
-        private static string GetContainerName(BlobProviderArgs args)
+        protected virtual string GetContainerName(BlobProviderArgs args)
         {
             var configuration = args.Configuration.GetAliyunConfiguration();
             return configuration.ContainerName.IsNullOrWhiteSpace()
                 ? args.ContainerName
-                : configuration.ContainerName;
+                : NormalizeContainerName(args, ServiceProvider, configuration.ContainerName);
         }
 
-        private bool BlobExists(IOss ossClient,string containerName, string blobName)
+        protected  virtual bool BlobExists(IOss ossClient,string containerName, string blobName)
         {
             // Make sure Blob Container exists.
             return ossClient.DoesBucketExist(containerName) &&

framework/src/Volo.Abp.BlobStoring.Aws/Volo/Abp/BlobStoring/Aws/AwsBlobProvider.cs

@@ -12,12 +12,16 @@ namespace Volo.Abp.BlobStoring.Aws
     {
         protected IAwsBlobNameCalculator AwsBlobNameCalculator { get; }
         protected IAmazonS3ClientFactory AmazonS3ClientFactory { get; }
+        protected IServiceProvider ServiceProvider { get; }
 
-        public AwsBlobProvider(IAwsBlobNameCalculator awsBlobNameCalculator,
+        public AwsBlobProvider(
-            IAmazonS3ClientFactory amazonS3ClientFactory)
+            IAwsBlobNameCalculator awsBlobNameCalculator,
+            IAmazonS3ClientFactory amazonS3ClientFactory,
+            IServiceProvider serviceProvider)
         {
             AwsBlobNameCalculator = awsBlobNameCalculator;
             AmazonS3ClientFactory = amazonS3ClientFactory;
+            ServiceProvider = serviceProvider;
         }
 
         public async override Task SaveAsync(BlobProviderSaveArgs args)
@@ -111,7 +115,7 @@ namespace Volo.Abp.BlobStoring.Aws
             return await AmazonS3ClientFactory.GetAmazonS3Client(configuration);
         }
 
-        private async Task<bool> BlobExistsAsync(AmazonS3Client amazonS3Client, string containerName, string blobName)
+        protected virtual async Task<bool> BlobExistsAsync(AmazonS3Client amazonS3Client, string containerName, string blobName)
         {
             // Make sure Blob Container exists.
             if (!await AmazonS3Util.DoesS3BucketExistV2Async(amazonS3Client, containerName))
@@ -147,12 +151,12 @@ namespace Volo.Abp.BlobStoring.Aws
             }
         }
 
-        private static string GetContainerName(BlobProviderArgs args)
+        protected virtual string GetContainerName(BlobProviderArgs args)
         {
             var configuration = args.Configuration.GetAwsConfiguration();
             return configuration.ContainerName.IsNullOrWhiteSpace()
                 ? args.ContainerName
-                : configuration.ContainerName;
+                : NormalizeContainerName(args, ServiceProvider, configuration.ContainerName);
         }
     }
 }

framework/src/Volo.Abp.BlobStoring.Azure/Volo/Abp/BlobStoring/Azure/AzureBlobProvider.cs

@@ -9,10 +9,12 @@ namespace Volo.Abp.BlobStoring.Azure
     public class AzureBlobProvider : BlobProviderBase, ITransientDependency
     {
         protected IAzureBlobNameCalculator AzureBlobNameCalculator { get; }
+        protected IServiceProvider ServiceProvider { get; }
 
-        public AzureBlobProvider(IAzureBlobNameCalculator azureBlobNameCalculator)
+        public AzureBlobProvider(IAzureBlobNameCalculator azureBlobNameCalculator, IServiceProvider serviceProvider)
         {
             AzureBlobNameCalculator = azureBlobNameCalculator;
+            ServiceProvider = serviceProvider;
         }
 
         public async override Task SaveAsync(BlobProviderSaveArgs args)
@@ -87,22 +89,22 @@ namespace Volo.Abp.BlobStoring.Azure
             await blobContainerClient.CreateIfNotExistsAsync();
         }
 
-        private async Task<bool> BlobExistsAsync(BlobProviderArgs args, string blobName)
+        protected virtual async Task<bool> BlobExistsAsync(BlobProviderArgs args, string blobName)
         {
             // Make sure Blob Container exists.
             return await ContainerExistsAsync(GetBlobContainerClient(args)) &&
                    (await GetBlobClient(args, blobName).ExistsAsync()).Value;
         }
 
-        private static string GetContainerName(BlobProviderArgs args)
+        protected virtual string GetContainerName(BlobProviderArgs args)
         {
             var configuration = args.Configuration.GetAzureConfiguration();
             return configuration.ContainerName.IsNullOrWhiteSpace()
                 ? args.ContainerName
-                : configuration.ContainerName;
+                : NormalizeContainerName(args, ServiceProvider, configuration.ContainerName);
         }
 
-        private static async Task<bool> ContainerExistsAsync(BlobContainerClient blobContainerClient)
+        protected virtual async Task<bool> ContainerExistsAsync(BlobContainerClient blobContainerClient)
         {
             return (await blobContainerClient.ExistsAsync()).Value;
         }

framework/src/Volo.Abp.BlobStoring.Minio/Volo/Abp/BlobStoring/Minio/MinioBlobContainerConfigurationExtensions.cs

@@ -15,6 +15,7 @@ namespace Volo.Abp.BlobStoring.Minio
             Action<MinioBlobProviderConfiguration> minioConfigureAction)
         {
             containerConfiguration.ProviderType = typeof(MinioBlobProvider);
+            containerConfiguration.NamingNormalizers.TryAdd<MinioBlobNamingNormalizer>();
 
             minioConfigureAction(new MinioBlobProviderConfiguration(containerConfiguration));
 

framework/src/Volo.Abp.BlobStoring.Minio/Volo/Abp/BlobStoring/Minio/MinioBlobProvider.cs

@@ -10,10 +10,12 @@ namespace Volo.Abp.BlobStoring.Minio
     public class MinioBlobProvider : BlobProviderBase, ITransientDependency
     {
         protected IMinioBlobNameCalculator MinioBlobNameCalculator { get; }
+        protected IServiceProvider ServiceProvider { get; }
 
-        public MinioBlobProvider(IMinioBlobNameCalculator minioBlobNameCalculator)
+        public MinioBlobProvider(IMinioBlobNameCalculator minioBlobNameCalculator, IServiceProvider serviceProvider)
         {
             MinioBlobNameCalculator = minioBlobNameCalculator;
+            ServiceProvider = serviceProvider;
         }
 
         public async override Task SaveAsync(BlobProviderSaveArgs args)
@@ -108,7 +110,7 @@ namespace Volo.Abp.BlobStoring.Minio
             }
         }
 
-        private async Task<bool> BlobExistsAsync(MinioClient client, string containerName , string blobName)
+        protected virtual async Task<bool> BlobExistsAsync(MinioClient client, string containerName , string blobName)
         {
             // Make sure Blob Container exists.
             if (await client.BucketExistsAsync(containerName))
@@ -133,13 +135,13 @@ namespace Volo.Abp.BlobStoring.Minio
             return false;
         }
 
-        private static string GetContainerName(BlobProviderArgs args)
+        protected virtual string GetContainerName(BlobProviderArgs args)
         {
             var configuration = args.Configuration.GetMinioConfiguration();
 
             return configuration.BucketName.IsNullOrWhiteSpace()
                 ? args.ContainerName
-                : configuration.BucketName;
+                : NormalizeContainerName(args, ServiceProvider, configuration.BucketName);
         }
     }
 }

framework/src/Volo.Abp.BlobStoring/Volo/Abp/BlobStoring/BlobProviderBase.cs

@@ -1,5 +1,8 @@
-using System.IO;
+using System;
+using System.IO;
+using System.Linq;
 using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace Volo.Abp.BlobStoring
 {
@@ -12,5 +15,27 @@ namespace Volo.Abp.BlobStoring
         public abstract Task<bool> ExistsAsync(BlobProviderExistsArgs args);
 
         public abstract Task<Stream> GetOrNullAsync(BlobProviderGetArgs args);
+
+        protected string NormalizeContainerName(BlobProviderArgs args, IServiceProvider serviceProvider, string containerName)
+        {
+            if (!args.Configuration.NamingNormalizers.Any())
+            {
+                return containerName;
+            }
+
+            using (var scope = serviceProvider.CreateScope())
+            {
+                foreach (var normalizerType in args.Configuration.NamingNormalizers)
+                {
+                    var normalizer = scope.ServiceProvider
+                        .GetRequiredService(normalizerType)
+                        .As<IBlobNamingNormalizer>();
+
+                    containerName = normalizer.NormalizeContainerName(containerName);
+                }
+
+                return containerName;
+            }
+        }
     }
-}
+}