feat: add more method in file manager

jxnkwlp · jxnkwlp · commit ac5e4a83f604 · 2023-09-12T18:12:03.000+08:00
diff --git a/modules/file-management/src/Directory.Build.props b/modules/file-management/src/Directory.Build.props
@@ -3,7 +3,7 @@
     <Product>Passingwind.Abp.FileManagement</Product>
     <Description>an abp module that provider file and file container management </Description>
     <Version>0.1.0</Version>
-    <PackageVersion>0.1.7</PackageVersion>
+    <PackageVersion>0.1.8</PackageVersion>
     <PackageReadmeFile>README.md</PackageReadmeFile>
   </PropertyGroup>
 
diff --git a/modules/file-management/src/Passingwind.Abp.FileManagement.Application.Contracts/Files/IFileIntegrationAppService.cs b/modules/file-management/src/Passingwind.Abp.FileManagement.Application.Contracts/Files/IFileIntegrationAppService.cs
@@ -0,0 +1,21 @@
+﻿using System;
+using System.IO;
+using System.Threading.Tasks;
+using Volo.Abp;
+using Volo.Abp.Application.Services;
+
+namespace Passingwind.Abp.FileManagement.Files;
+
+[IntegrationService]
+public interface IFileIntegrationAppService : IApplicationService
+{
+    Task<FileContainerDto> GetContainerAsync(Guid id);
+
+    Task<FileDto> GetAsync(string containerName, Guid id);
+
+    Task<Stream?> GetStreamAsync(string containerName, Guid id);
+    Task<byte[]> GetBytesAsync(string containerName, Guid id);
+
+    Task<FileDto> CreateByStreamAsync(string containerName, FileCreateByStreamDto input);
+    Task<FileDto> CreateByBytesAsync(string containerName, FileCreateByBytesDto input);
+}
diff --git a/modules/file-management/src/Passingwind.Abp.FileManagement.Application/Files/FileIntegrationAppService.cs b/modules/file-management/src/Passingwind.Abp.FileManagement.Application/Files/FileIntegrationAppService.cs
@@ -0,0 +1,38 @@
+﻿//using System;
+//using System.IO;
+//using System.Threading.Tasks;
+
+//namespace Passingwind.Abp.FileManagement.Files;
+
+//public class FileIntegrationAppService : FileManagementAppService, IFileIntegrationAppService
+//{
+//    public Task<FileDto> CreateByBytesAsync(string containerName, FileCreateByBytesDto input)
+//    {
+//        throw new NotImplementedException();
+//    }
+
+//    public Task<FileDto> CreateByStreamAsync(string containerName, FileCreateByStreamDto input)
+//    {
+//        throw new NotImplementedException();
+//    }
+
+//    public Task<FileDto> GetAsync(string containerName, Guid id)
+//    {
+//        throw new NotImplementedException();
+//    }
+
+//    public Task<byte[]> GetBytesAsync(string containerName, Guid id)
+//    {
+//        throw new NotImplementedException();
+//    }
+
+//    public Task<FileContainerDto> GetContainerAsync(Guid id)
+//    {
+//        throw new NotImplementedException();
+//    }
+
+//    public Task<Stream?> GetStreamAsync(string containerName, Guid id)
+//    {
+//        throw new NotImplementedException();
+//    }
+//}
diff --git a/modules/file-management/src/Passingwind.Abp.FileManagement.Domain/BackgroundWorkers/FileShareTokenCleanupBackgroundWorker.cs b/modules/file-management/src/Passingwind.Abp.FileManagement.Domain/BackgroundWorkers/FileShareTokenCleanupBackgroundWorker.cs
@@ -12,8 +12,8 @@ public class FileShareTokenCleanupBackgroundWorker : AsyncPeriodicBackgroundWork
 {
     public FileShareTokenCleanupBackgroundWorker(AbpAsyncTimer timer, IServiceScopeFactory serviceScopeFactory) : base(timer, serviceScopeFactory)
     {
-        // 12h
-        Timer.Period = 12 * 60 * 60 * 1000;
+        // 6h
+        Timer.Period = 6 * 60 * 60 * 1000;
     }
 
     protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext)
diff --git a/modules/file-management/src/Passingwind.Abp.FileManagement.Domain/Files/FileContainerManager.cs b/modules/file-management/src/Passingwind.Abp.FileManagement.Domain/Files/FileContainerManager.cs
@@ -1,4 +1,5 @@
-﻿using System.Threading;
+﻿using System;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Options;
 using Passingwind.Abp.FileManagement.Options;
@@ -8,23 +9,33 @@ namespace Passingwind.Abp.FileManagement.Files;
 
 public class FileContainerManager : DomainService
 {
-    private readonly IFileContainerRepository _fileContainerRepository;
-    private readonly FileManagementOptions _options;
+    protected IFileContainerRepository FileContainerRepository { get; }
+    protected FileManagementOptions FileManagementOptions { get; }
 
     public FileContainerManager(IFileContainerRepository fileContainerRepository, IOptions<FileManagementOptions> options)
     {
-        _fileContainerRepository = fileContainerRepository;
-        _options = options.Value;
+        FileContainerRepository = fileContainerRepository;
+        FileManagementOptions = options.Value;
+    }
+
+    public virtual async Task<FileContainer> GetByIdAsync(Guid id, CancellationToken cancellationToken = default)
+    {
+        return await FileContainerRepository.GetAsync(id, cancellationToken: cancellationToken);
+    }
+
+    public virtual async Task<FileContainer> GetByNameAsync(string name, CancellationToken cancellationToken = default)
+    {
+        return await FileContainerRepository.GetByNameAsync(name, cancellationToken);
     }
 
     public virtual async Task<bool> IsExistsAsync(FileContainer fileContainer, CancellationToken cancellationToken = default)
     {
-        return await _fileContainerRepository.CheckExistsAsync(fileContainer, cancellationToken);
+        return await FileContainerRepository.CheckExistsAsync(fileContainer, cancellationToken);
     }
 
     public virtual async Task CheckExistsAsync(string name, CancellationToken cancellationToken = default)
     {
-        _ = await _fileContainerRepository.GetByNameAsync(name, cancellationToken);
+        _ = await FileContainerRepository.GetByNameAsync(name, cancellationToken);
     }
 
     public virtual Task<FileContainer> CreateAsync(
@@ -39,15 +50,15 @@ public virtual Task<FileContainer> CreateAsync(
         string? prohibitedFileExtensions = null,
         bool? autoDeleteBlob = false)
     {
-        var entity = new FileContainer(GuidGenerator.Create(), name, accessMode ?? _options.DefaultContainerAccessMode)
+        var entity = new FileContainer(GuidGenerator.Create(), name, accessMode ?? FileManagementOptions.DefaultContainerAccessMode)
         {
             Description = description,
-            MaximumEachFileSize = maximumEachFileSize ?? _options.DefaultMaximumFileSize,
-            MaximumFileQuantity = maximumFileQuantity ?? _options.DefaultContainerMaximumFileQuantity,
+            MaximumEachFileSize = maximumEachFileSize ?? FileManagementOptions.DefaultMaximumFileSize,
+            MaximumFileQuantity = maximumFileQuantity ?? FileManagementOptions.DefaultContainerMaximumFileQuantity,
             AllowAnyFileExtension = allowAnyFileExtension ?? false,
-            AllowedFileExtensions = allowedFileExtensions ?? string.Join(",", _options.DefaultAllowedFileExtensions ?? new string[0]),
-            ProhibitedFileExtensions = prohibitedFileExtensions ?? string.Join(",", _options.DefaultProhibitedFileExtensions ?? new string[0]),
-            OverrideBehavior = overrideBehavior ?? _options.DefaultOverrideBehavior,
+            AllowedFileExtensions = allowedFileExtensions ?? string.Join(",", FileManagementOptions.DefaultAllowedFileExtensions ?? new string[0]),
+            ProhibitedFileExtensions = prohibitedFileExtensions ?? string.Join(",", FileManagementOptions.DefaultProhibitedFileExtensions ?? new string[0]),
+            OverrideBehavior = overrideBehavior ?? FileManagementOptions.DefaultOverrideBehavior,
             AutoDeleteBlob = autoDeleteBlob ?? false,
         };
 
diff --git a/modules/file-management/src/Passingwind.Abp.FileManagement.Domain/Files/FileManager.cs b/modules/file-management/src/Passingwind.Abp.FileManagement.Domain/Files/FileManager.cs
@@ -15,16 +15,16 @@ namespace Passingwind.Abp.FileManagement.Files;
 
 public class FileManager : DomainService, IFileManager
 {
-    private readonly IFileRepository _fileRepository;
-    private readonly IFileContainerRepository _fileContainerRepository;
-    private readonly IBlobContainerFactory _blobContainerFactor;
-    private readonly IFileBlobNameGenerator _fileBlobNameGenerator;
-    private readonly IFileHashCalculator _fileHashCalculator;
-    private readonly IFileMimeTypeProvider _fileMimeTypeProvider;
-    private readonly IFileUniqueIdGenerator _fileUniqueIdGenerator;
-    private readonly IFileBlobContainerProvider _fileBlobContainerProvider;
-    private readonly IFileDuplicateDetectionProvider _fileDuplicateDetectionProvider;
-    private readonly FileManagementOptions _options;
+    private IFileRepository FileRepository { get; }
+    private IFileContainerRepository FileContainerRepository { get; }
+    private IBlobContainerFactory BlobContainerFactor { get; }
+    private IFileBlobNameGenerator FileBlobNameGenerator { get; }
+    private IFileHashCalculator FileHashCalculator { get; }
+    private IFileMimeTypeProvider FileMimeTypeProvider { get; }
+    private IFileUniqueIdGenerator FileUniqueIdGenerator { get; }
+    private IFileBlobContainerProvider FileBlobContainerProvider { get; }
+    private IFileDuplicateDetectionProvider FileDuplicateDetectionProvider { get; }
+    private FileManagementOptions FileManagementOptions { get; }
 
     public FileManager(
         IFileRepository fileRepository,
@@ -38,19 +38,19 @@ public FileManager(
         IFileDuplicateDetectionProvider fileDuplicateDetectionProvider,
         IOptions<FileManagementOptions> options)
     {
-        _fileRepository = fileRepository;
-        _fileContainerRepository = fileContainerRepository;
-        _blobContainerFactor = blobContainerFactor;
-        _fileBlobNameGenerator = fileBlobNameGenerator;
-        _fileHashCalculator = fileHashCalculator;
-        _fileMimeTypeProvider = fileMimeTypeProvider;
-        _fileUniqueIdGenerator = fileUniqueIdGenerator;
-        _fileBlobContainerProvider = fileBlobContainerProvider;
-        _fileDuplicateDetectionProvider = fileDuplicateDetectionProvider;
-        _options = options.Value;
+        FileRepository = fileRepository;
+        FileContainerRepository = fileContainerRepository;
+        BlobContainerFactor = blobContainerFactor;
+        FileBlobNameGenerator = fileBlobNameGenerator;
+        FileHashCalculator = fileHashCalculator;
+        FileMimeTypeProvider = fileMimeTypeProvider;
+        FileUniqueIdGenerator = fileUniqueIdGenerator;
+        FileBlobContainerProvider = fileBlobContainerProvider;
+        FileDuplicateDetectionProvider = fileDuplicateDetectionProvider;
+        FileManagementOptions = options.Value;
     }
 
-    public async Task<File> FindFileAsync(FileContainer container, string fileName, Guid? parentId, CancellationToken cancellationToken = default)
+    public virtual async Task<File> FindFileAsync(FileContainer container, string fileName, Guid? parentId, CancellationToken cancellationToken = default)
     {
         if (container is null)
         {
@@ -62,7 +62,7 @@ public async Task<File> FindFileAsync(FileContainer container, string fileName,
             throw new ArgumentException($"'{nameof(fileName)}' cannot be null or empty.", nameof(fileName));
         }
 
-        return await _fileRepository.FirstOrDefaultAsync(x => x.FileName == fileName && x.ParentId == parentId && x.ContainerId == container.Id && !x.IsDirectory);
+        return await FileRepository.FirstOrDefaultAsync(x => x.FileName == fileName && x.ParentId == parentId && x.ContainerId == container.Id && !x.IsDirectory);
     }
 
     public virtual async Task<bool> IsFileExistsAsync(FileContainer container, File file, CancellationToken cancellationToken = default)
@@ -80,7 +80,7 @@ public virtual async Task<bool> IsFileExistsAsync(FileContainer container, File
         if (file.IsDirectory)
             throw new ArgumentException();
 
-        return await _fileDuplicateDetectionProvider.IsExistsAsync(container, file, cancellationToken);
+        return await FileDuplicateDetectionProvider.IsExistsAsync(container, file, cancellationToken);
     }
 
     public virtual async Task<bool> IsDirectoryExistsAsync(FileContainer container, File file, CancellationToken cancellationToken = default)
@@ -98,7 +98,7 @@ public virtual async Task<bool> IsDirectoryExistsAsync(FileContainer container,
         if (!file.IsDirectory)
             throw new ArgumentException();
 
-        return await _fileDuplicateDetectionProvider.IsExistsAsync(container, file, cancellationToken);
+        return await FileDuplicateDetectionProvider.IsExistsAsync(container, file, cancellationToken);
     }
 
     public virtual Task CheckFileExtensionAsync(FileContainer container, File file, CancellationToken cancellationToken = default)
@@ -180,7 +180,7 @@ public virtual async Task CheckFileExistsAsync(FileContainer container, File fil
         }
     }
 
-    public async Task CheckDirectoryExistsAsync(FileContainer container, File entity, CancellationToken cancellationToken = default)
+    public virtual async Task CheckDirectoryExistsAsync(FileContainer container, File entity, CancellationToken cancellationToken = default)
     {
         if (container is null)
         {
@@ -221,11 +221,11 @@ public virtual async Task<File> CreateFileAsync(FileContainer container, string
             throw new ArgumentNullException(nameof(bytes));
         }
 
-        var hash = await _fileHashCalculator.GetAsync(bytes);
+        var hash = await FileHashCalculator.GetAsync(bytes);
 
         var fileId = GuidGenerator.Create();
-        var uniqueId = await _fileUniqueIdGenerator.CreateAsync(container, fileId);
-        var blobName = await _fileBlobNameGenerator.CreateAsync(container.Id, fileId, uniqueId, fileName, mimeType, bytes.Length, hash);
+        var uniqueId = await FileUniqueIdGenerator.CreateAsync(container, fileId);
+        var blobName = await FileBlobNameGenerator.CreateAsync(container.Id, fileId, uniqueId, fileName, mimeType, bytes.Length, hash);
 
         var file = new File(
             fileId,
@@ -243,7 +243,7 @@ public virtual async Task<File> CreateFileAsync(FileContainer container, string
         return file;
     }
 
-    public async Task<File> CreateDirectoryAsync(FileContainer container, string name, Guid? parentId, CancellationToken cancellationToken = default)
+    public virtual async Task<File> CreateDirectoryAsync(FileContainer container, string name, Guid? parentId, CancellationToken cancellationToken = default)
     {
         if (container is null)
         {
@@ -256,8 +256,8 @@ public async Task<File> CreateDirectoryAsync(FileContainer container, string nam
         }
 
         var fileId = GuidGenerator.Create();
-        var uniqueId = await _fileUniqueIdGenerator.CreateAsync(container, fileId);
-        var blobName = await _fileBlobNameGenerator.CreateAsync(container.Id, fileId, uniqueId, name, string.Empty, 0, string.Empty);
+        var uniqueId = await FileUniqueIdGenerator.CreateAsync(container, fileId);
+        var blobName = await FileBlobNameGenerator.CreateAsync(container.Id, fileId, uniqueId, name, string.Empty, 0, string.Empty);
 
         var file = new File(
             fileId,
@@ -309,7 +309,7 @@ public virtual async Task<byte[]> GetFileBytesAsync(FileContainer container, Fil
             throw new ArgumentNullException(nameof(file));
         }
 
-        var blobContainer = await _fileBlobContainerProvider.GetAsync(container);
+        var blobContainer = await FileBlobContainerProvider.GetAsync(container);
 
         return await blobContainer.GetAllBytesOrNullAsync(file.BlobName, cancellationToken);
     }
@@ -326,7 +326,7 @@ public virtual async Task<byte[]> GetFileBytesAsync(FileContainer container, Fil
             throw new ArgumentNullException(nameof(file));
         }
 
-        var blobContainer = await _fileBlobContainerProvider.GetAsync(container);
+        var blobContainer = await FileBlobContainerProvider.GetAsync(container);
 
         return await blobContainer.GetOrNullAsync(file.BlobName, cancellationToken);
     }
@@ -348,7 +348,7 @@ public virtual async Task SaveBlobAsync(FileContainer container, File file, Stre
             throw new ArgumentNullException(nameof(stream));
         }
 
-        var blobContainer = await _fileBlobContainerProvider.GetAsync(container);
+        var blobContainer = await FileBlobContainerProvider.GetAsync(container);
 
         await blobContainer.SaveAsync(file.BlobName, stream, true, cancellationToken);
     }
@@ -370,12 +370,12 @@ public virtual async Task SaveBlobAsync(FileContainer container, File file, byte
             throw new ArgumentNullException(nameof(bytes));
         }
 
-        var blobContainer = await _fileBlobContainerProvider.GetAsync(container);
+        var blobContainer = await FileBlobContainerProvider.GetAsync(container);
 
         await blobContainer.SaveAsync(file.BlobName, bytes, true, cancellationToken);
     }
 
-    public async Task<File> ChangeFileNameAsync(FileContainer container, File file, string newName, Guid? parentId, CancellationToken cancellationToken = default)
+    public virtual async Task<File> ChangeFileNameAsync(FileContainer container, File file, string newName, Guid? parentId, CancellationToken cancellationToken = default)
     {
         if (container == null)
             throw new ArgumentNullException(nameof(container));
@@ -392,43 +392,62 @@ public async Task<File> ChangeFileNameAsync(FileContainer container, File file,
         file.SetFileName(newName);
 
         if (!file.IsDirectory)
-            file.UpdateMimeType(_fileMimeTypeProvider.Get(newName));
+            file.UpdateMimeType(FileMimeTypeProvider.Get(newName));
 
         await CheckFileExtensionAsync(container, file);
 
         return file;
     }
 
     [UnitOfWork]
-    public async Task DeleteAsync(FileContainer container, File file, CancellationToken cancellationToken = default)
+    public virtual async Task DeleteAsync(FileContainer container, File file, CancellationToken cancellationToken = default)
     {
-        await _fileRepository.DeleteAsync(file);
+        await FileRepository.DeleteAsync(file);
 
         if (container.AutoDeleteBlob && !file.IsDirectory)
         {
-            var blobContainer = await _fileBlobContainerProvider.GetAsync(container, cancellationToken: cancellationToken);
+            var blobContainer = await FileBlobContainerProvider.GetAsync(container, cancellationToken: cancellationToken);
 
             await blobContainer.DeleteAsync(file.BlobName, cancellationToken);
         }
     }
 
     [UnitOfWork]
-    public async Task ClearContainerFilesAsync(FileContainer container, CancellationToken cancellationToken = default)
+    public virtual async Task ClearContainerFilesAsync(FileContainer container, CancellationToken cancellationToken = default)
     {
         // TODO: performance
 
-        var files = await _fileRepository.GetListAsync(containerId: container.Id, cancellationToken: cancellationToken);
+        var files = await FileRepository.GetListAsync(containerId: container.Id, cancellationToken: cancellationToken);
 
         foreach (var file in files)
         {
-            await _fileRepository.DeleteAsync(file);
+            await FileRepository.DeleteAsync(file);
 
             if (container.AutoDeleteBlob && !file.IsDirectory)
             {
-                var blobContainer = await _fileBlobContainerProvider.GetAsync(container, cancellationToken: cancellationToken);
+                var blobContainer = await FileBlobContainerProvider.GetAsync(container, cancellationToken: cancellationToken);
 
                 await blobContainer.DeleteAsync(file.BlobName, cancellationToken);
             }
         }
     }
+
+    public async Task<byte[]> GetFileBytesByFileIdAsync(string containerName, Guid id, CancellationToken cancellationToken = default)
+    {
+        var container = await FileContainerRepository.GetByNameAsync(containerName, cancellationToken);
+        var file = await FileRepository.GetAsync(id, cancellationToken: cancellationToken);
+        return await GetFileBytesAsync(container, file, cancellationToken);
+    }
+
+    public async Task<Stream?> GetFileSteamByFileIdAsync(string containerName, Guid id, CancellationToken cancellationToken = default)
+    {
+        var container = await FileContainerRepository.GetByNameAsync(containerName, cancellationToken);
+        var file = await FileRepository.GetAsync(id, cancellationToken: cancellationToken);
+        return await GetFileSteamAsync(container, file, cancellationToken);
+    }
+
+    public async Task<File> GetByIdAsync(string containerName, Guid id, CancellationToken cancellationToken = default)
+    {
+        return await FileRepository.GetAsync(id, cancellationToken: cancellationToken);
+    }
 }
diff --git a/modules/file-management/src/Passingwind.Abp.FileManagement.Domain/Files/IFileManager.cs b/modules/file-management/src/Passingwind.Abp.FileManagement.Domain/Files/IFileManager.cs
diff --git a/modules/file-management/src/Passingwind.Abp.FileManagement.HttpApi/Files/FileIntegrationController.cs b/modules/file-management/src/Passingwind.Abp.FileManagement.HttpApi/Files/FileIntegrationController.cs

Original file line number	Diff line number	Diff line change
`@@ -12,8 +12,8 @@ public class FileShareTokenCleanupBackgroundWorker : AsyncPeriodicBackgroundWork`
`12`	`12`	`{`
`13`	`13`	`public FileShareTokenCleanupBackgroundWorker(AbpAsyncTimer timer, IServiceScopeFactory serviceScopeFactory) : base(timer, serviceScopeFactory)`
`14`	`14`	`{`
`15`		`- // 12h`
`16`		`- Timer.Period = 12 * 60 * 60 * 1000;`
	`15`	`+ // 6h`
	`16`	`+ Timer.Period = 6 * 60 * 60 * 1000;`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext)`
Original file line number	Diff line number	Diff line change
`@@ -15,16 +15,16 @@ namespace Passingwind.Abp.FileManagement.Files;`
`15`	`15`
`16`	`16`	`public class FileManager : DomainService, IFileManager`
`17`	`17`	`{`
`18`		`- private readonly IFileRepository _fileRepository;`
`19`		`- private readonly IFileContainerRepository _fileContainerRepository;`
`20`		`- private readonly IBlobContainerFactory _blobContainerFactor;`
`21`		`- private readonly IFileBlobNameGenerator _fileBlobNameGenerator;`
`22`		`- private readonly IFileHashCalculator _fileHashCalculator;`
`23`		`- private readonly IFileMimeTypeProvider _fileMimeTypeProvider;`
`24`		`- private readonly IFileUniqueIdGenerator _fileUniqueIdGenerator;`
`25`		`- private readonly IFileBlobContainerProvider _fileBlobContainerProvider;`
`26`		`- private readonly IFileDuplicateDetectionProvider _fileDuplicateDetectionProvider;`
`27`		`- private readonly FileManagementOptions _options;`
	`18`	`+ private IFileRepository FileRepository { get; }`
	`19`	`+ private IFileContainerRepository FileContainerRepository { get; }`
	`20`	`+ private IBlobContainerFactory BlobContainerFactor { get; }`
	`21`	`+ private IFileBlobNameGenerator FileBlobNameGenerator { get; }`
	`22`	`+ private IFileHashCalculator FileHashCalculator { get; }`
	`23`	`+ private IFileMimeTypeProvider FileMimeTypeProvider { get; }`
	`24`	`+ private IFileUniqueIdGenerator FileUniqueIdGenerator { get; }`
	`25`	`+ private IFileBlobContainerProvider FileBlobContainerProvider { get; }`
	`26`	`+ private IFileDuplicateDetectionProvider FileDuplicateDetectionProvider { get; }`
	`27`	`+ private FileManagementOptions FileManagementOptions { get; }`
`28`	`28`
`29`	`29`	`public FileManager(`
`30`	`30`	`IFileRepository fileRepository,`
`@@ -38,19 +38,19 @@ public FileManager(`
`38`	`38`	`IFileDuplicateDetectionProvider fileDuplicateDetectionProvider,`
`39`	`39`	`IOptions<FileManagementOptions> options)`
`40`	`40`	`{`
`41`		`- _fileRepository = fileRepository;`
`42`		`- _fileContainerRepository = fileContainerRepository;`
`43`		`- _blobContainerFactor = blobContainerFactor;`
`44`		`- _fileBlobNameGenerator = fileBlobNameGenerator;`
`45`		`- _fileHashCalculator = fileHashCalculator;`
`46`		`- _fileMimeTypeProvider = fileMimeTypeProvider;`
`47`		`- _fileUniqueIdGenerator = fileUniqueIdGenerator;`
`48`		`- _fileBlobContainerProvider = fileBlobContainerProvider;`
`49`		`- _fileDuplicateDetectionProvider = fileDuplicateDetectionProvider;`
`50`		`- _options = options.Value;`
	`41`	`+ FileRepository = fileRepository;`
	`42`	`+ FileContainerRepository = fileContainerRepository;`
	`43`	`+ BlobContainerFactor = blobContainerFactor;`
	`44`	`+ FileBlobNameGenerator = fileBlobNameGenerator;`
	`45`	`+ FileHashCalculator = fileHashCalculator;`
	`46`	`+ FileMimeTypeProvider = fileMimeTypeProvider;`
	`47`	`+ FileUniqueIdGenerator = fileUniqueIdGenerator;`
	`48`	`+ FileBlobContainerProvider = fileBlobContainerProvider;`
	`49`	`+ FileDuplicateDetectionProvider = fileDuplicateDetectionProvider;`
	`50`	`+ FileManagementOptions = options.Value;`
`51`	`51`	`}`
`52`	`52`
`53`		`- public async Task<File> FindFileAsync(FileContainer container, string fileName, Guid? parentId, CancellationToken cancellationToken = default)`
	`53`	`+ public virtual async Task<File> FindFileAsync(FileContainer container, string fileName, Guid? parentId, CancellationToken cancellationToken = default)`
`54`	`54`	`{`
`55`	`55`	`if (container is null)`
`56`	`56`	`{`
`@@ -62,7 +62,7 @@ public async Task<File> FindFileAsync(FileContainer container, string fileName,`
`62`	`62`	`throw new ArgumentException($"'{nameof(fileName)}' cannot be null or empty.", nameof(fileName));`
`63`	`63`	`}`
`64`	`64`
`65`		`- return await _fileRepository.FirstOrDefaultAsync(x => x.FileName == fileName && x.ParentId == parentId && x.ContainerId == container.Id && !x.IsDirectory);`
	`65`	`+ return await FileRepository.FirstOrDefaultAsync(x => x.FileName == fileName && x.ParentId == parentId && x.ContainerId == container.Id && !x.IsDirectory);`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`public virtual async Task<bool> IsFileExistsAsync(FileContainer container, File file, CancellationToken cancellationToken = default)`
`@@ -80,7 +80,7 @@ public virtual async Task<bool> IsFileExistsAsync(FileContainer container, File`
`80`	`80`	`if (file.IsDirectory)`
`81`	`81`	`throw new ArgumentException();`
`82`	`82`
`83`		`- return await _fileDuplicateDetectionProvider.IsExistsAsync(container, file, cancellationToken);`
	`83`	`+ return await FileDuplicateDetectionProvider.IsExistsAsync(container, file, cancellationToken);`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`public virtual async Task<bool> IsDirectoryExistsAsync(FileContainer container, File file, CancellationToken cancellationToken = default)`
`@@ -98,7 +98,7 @@ public virtual async Task<bool> IsDirectoryExistsAsync(FileContainer container,`
`98`	`98`	`if (!file.IsDirectory)`
`99`	`99`	`throw new ArgumentException();`
`100`	`100`
`101`		`- return await _fileDuplicateDetectionProvider.IsExistsAsync(container, file, cancellationToken);`
	`101`	`+ return await FileDuplicateDetectionProvider.IsExistsAsync(container, file, cancellationToken);`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`public virtual Task CheckFileExtensionAsync(FileContainer container, File file, CancellationToken cancellationToken = default)`
`@@ -180,7 +180,7 @@ public virtual async Task CheckFileExistsAsync(FileContainer container, File fil`
`180`	`180`	`}`
`181`	`181`	`}`
`182`	`182`
`183`		`- public async Task CheckDirectoryExistsAsync(FileContainer container, File entity, CancellationToken cancellationToken = default)`
	`183`	`+ public virtual async Task CheckDirectoryExistsAsync(FileContainer container, File entity, CancellationToken cancellationToken = default)`
`184`	`184`	`{`
`185`	`185`	`if (container is null)`
`186`	`186`	`{`
`@@ -221,11 +221,11 @@ public virtual async Task<File> CreateFileAsync(FileContainer container, string`
`221`	`221`	`throw new ArgumentNullException(nameof(bytes));`
`222`	`222`	`}`
`223`	`223`
`224`		`- var hash = await _fileHashCalculator.GetAsync(bytes);`
	`224`	`+ var hash = await FileHashCalculator.GetAsync(bytes);`
`225`	`225`
`226`	`226`	`var fileId = GuidGenerator.Create();`
`227`		`- var uniqueId = await _fileUniqueIdGenerator.CreateAsync(container, fileId);`
`228`		`- var blobName = await _fileBlobNameGenerator.CreateAsync(container.Id, fileId, uniqueId, fileName, mimeType, bytes.Length, hash);`
	`227`	`+ var uniqueId = await FileUniqueIdGenerator.CreateAsync(container, fileId);`
	`228`	`+ var blobName = await FileBlobNameGenerator.CreateAsync(container.Id, fileId, uniqueId, fileName, mimeType, bytes.Length, hash);`
`229`	`229`
`230`	`230`	`var file = new File(`
`231`	`231`	`fileId,`
`@@ -243,7 +243,7 @@ public virtual async Task<File> CreateFileAsync(FileContainer container, string`
`243`	`243`	`return file;`
`244`	`244`	`}`
`245`	`245`
`246`		`- public async Task<File> CreateDirectoryAsync(FileContainer container, string name, Guid? parentId, CancellationToken cancellationToken = default)`
	`246`	`+ public virtual async Task<File> CreateDirectoryAsync(FileContainer container, string name, Guid? parentId, CancellationToken cancellationToken = default)`
`247`	`247`	`{`
`248`	`248`	`if (container is null)`
`249`	`249`	`{`
`@@ -256,8 +256,8 @@ public async Task<File> CreateDirectoryAsync(FileContainer container, string nam`
`256`	`256`	`}`
`257`	`257`
`258`	`258`	`var fileId = GuidGenerator.Create();`
`259`		`- var uniqueId = await _fileUniqueIdGenerator.CreateAsync(container, fileId);`
`260`		`- var blobName = await _fileBlobNameGenerator.CreateAsync(container.Id, fileId, uniqueId, name, string.Empty, 0, string.Empty);`
	`259`	`+ var uniqueId = await FileUniqueIdGenerator.CreateAsync(container, fileId);`
	`260`	`+ var blobName = await FileBlobNameGenerator.CreateAsync(container.Id, fileId, uniqueId, name, string.Empty, 0, string.Empty);`
`261`	`261`
`262`	`262`	`var file = new File(`
`263`	`263`	`fileId,`
`@@ -309,7 +309,7 @@ public virtual async Task<byte[]> GetFileBytesAsync(FileContainer container, Fil`
`309`	`309`	`throw new ArgumentNullException(nameof(file));`
`310`	`310`	`}`
`311`	`311`
`312`		`- var blobContainer = await _fileBlobContainerProvider.GetAsync(container);`
	`312`	`+ var blobContainer = await FileBlobContainerProvider.GetAsync(container);`
`313`	`313`
`314`	`314`	`return await blobContainer.GetAllBytesOrNullAsync(file.BlobName, cancellationToken);`
`315`	`315`	`}`
`@@ -326,7 +326,7 @@ public virtual async Task<byte[]> GetFileBytesAsync(FileContainer container, Fil`
`326`	`326`	`throw new ArgumentNullException(nameof(file));`
`327`	`327`	`}`
`328`	`328`
`329`		`- var blobContainer = await _fileBlobContainerProvider.GetAsync(container);`
	`329`	`+ var blobContainer = await FileBlobContainerProvider.GetAsync(container);`
`330`	`330`
`331`	`331`	`return await blobContainer.GetOrNullAsync(file.BlobName, cancellationToken);`
`332`	`332`	`}`
`@@ -348,7 +348,7 @@ public virtual async Task SaveBlobAsync(FileContainer container, File file, Stre`
`348`	`348`	`throw new ArgumentNullException(nameof(stream));`
`349`	`349`	`}`
`350`	`350`
`351`		`- var blobContainer = await _fileBlobContainerProvider.GetAsync(container);`
	`351`	`+ var blobContainer = await FileBlobContainerProvider.GetAsync(container);`
`352`	`352`
`353`	`353`	`await blobContainer.SaveAsync(file.BlobName, stream, true, cancellationToken);`
`354`	`354`	`}`
`@@ -370,12 +370,12 @@ public virtual async Task SaveBlobAsync(FileContainer container, File file, byte`
`370`	`370`	`throw new ArgumentNullException(nameof(bytes));`
`371`	`371`	`}`
`372`	`372`
`373`		`- var blobContainer = await _fileBlobContainerProvider.GetAsync(container);`
	`373`	`+ var blobContainer = await FileBlobContainerProvider.GetAsync(container);`
`374`	`374`
`375`	`375`	`await blobContainer.SaveAsync(file.BlobName, bytes, true, cancellationToken);`
`376`	`376`	`}`
`377`	`377`
`378`		`- public async Task<File> ChangeFileNameAsync(FileContainer container, File file, string newName, Guid? parentId, CancellationToken cancellationToken = default)`
	`378`	`+ public virtual async Task<File> ChangeFileNameAsync(FileContainer container, File file, string newName, Guid? parentId, CancellationToken cancellationToken = default)`
`379`	`379`	`{`
`380`	`380`	`if (container == null)`
`381`	`381`	`throw new ArgumentNullException(nameof(container));`
`@@ -392,43 +392,62 @@ public async Task<File> ChangeFileNameAsync(FileContainer container, File file,`
`392`	`392`	`file.SetFileName(newName);`
`393`	`393`
`394`	`394`	`if (!file.IsDirectory)`
`395`		`- file.UpdateMimeType(_fileMimeTypeProvider.Get(newName));`
	`395`	`+ file.UpdateMimeType(FileMimeTypeProvider.Get(newName));`
`396`	`396`
`397`	`397`	`await CheckFileExtensionAsync(container, file);`
`398`	`398`
`399`	`399`	`return file;`
`400`	`400`	`}`
`401`	`401`
`402`	`402`	`[UnitOfWork]`
`403`		`- public async Task DeleteAsync(FileContainer container, File file, CancellationToken cancellationToken = default)`
	`403`	`+ public virtual async Task DeleteAsync(FileContainer container, File file, CancellationToken cancellationToken = default)`
`404`	`404`	`{`
`405`		`- await _fileRepository.DeleteAsync(file);`
	`405`	`+ await FileRepository.DeleteAsync(file);`
`406`	`406`
`407`	`407`	`if (container.AutoDeleteBlob && !file.IsDirectory)`
`408`	`408`	`{`
`409`		`- var blobContainer = await _fileBlobContainerProvider.GetAsync(container, cancellationToken: cancellationToken);`
	`409`	`+ var blobContainer = await FileBlobContainerProvider.GetAsync(container, cancellationToken: cancellationToken);`
`410`	`410`
`411`	`411`	`await blobContainer.DeleteAsync(file.BlobName, cancellationToken);`
`412`	`412`	`}`
`413`	`413`	`}`
`414`	`414`
`415`	`415`	`[UnitOfWork]`
`416`		`- public async Task ClearContainerFilesAsync(FileContainer container, CancellationToken cancellationToken = default)`
	`416`	`+ public virtual async Task ClearContainerFilesAsync(FileContainer container, CancellationToken cancellationToken = default)`
`417`	`417`	`{`
`418`	`418`	`// TODO: performance`
`419`	`419`
`420`		`- var files = await _fileRepository.GetListAsync(containerId: container.Id, cancellationToken: cancellationToken);`
	`420`	`+ var files = await FileRepository.GetListAsync(containerId: container.Id, cancellationToken: cancellationToken);`
`421`	`421`
`422`	`422`	`foreach (var file in files)`
`423`	`423`	`{`
`424`		`- await _fileRepository.DeleteAsync(file);`
	`424`	`+ await FileRepository.DeleteAsync(file);`
`425`	`425`
`426`	`426`	`if (container.AutoDeleteBlob && !file.IsDirectory)`
`427`	`427`	`{`
`428`		`- var blobContainer = await _fileBlobContainerProvider.GetAsync(container, cancellationToken: cancellationToken);`
	`428`	`+ var blobContainer = await FileBlobContainerProvider.GetAsync(container, cancellationToken: cancellationToken);`
`429`	`429`
`430`	`430`	`await blobContainer.DeleteAsync(file.BlobName, cancellationToken);`
`431`	`431`	`}`
`432`	`432`	`}`
`433`	`433`	`}`
	`434`	`+`
	`435`	`+ public async Task<byte[]> GetFileBytesByFileIdAsync(string containerName, Guid id, CancellationToken cancellationToken = default)`
	`436`	`+ {`
	`437`	`+ var container = await FileContainerRepository.GetByNameAsync(containerName, cancellationToken);`
	`438`	`+ var file = await FileRepository.GetAsync(id, cancellationToken: cancellationToken);`
	`439`	`+ return await GetFileBytesAsync(container, file, cancellationToken);`
	`440`	`+ }`
	`441`	`+`
	`442`	`+ public async Task<Stream?> GetFileSteamByFileIdAsync(string containerName, Guid id, CancellationToken cancellationToken = default)`
	`443`	`+ {`
	`444`	`+ var container = await FileContainerRepository.GetByNameAsync(containerName, cancellationToken);`
	`445`	`+ var file = await FileRepository.GetAsync(id, cancellationToken: cancellationToken);`
	`446`	`+ return await GetFileSteamAsync(container, file, cancellationToken);`
	`447`	`+ }`
	`448`	`+`
	`449`	`+ public async Task<File> GetByIdAsync(string containerName, Guid id, CancellationToken cancellationToken = default)`
	`450`	`+ {`
	`451`	`+ return await FileRepository.GetAsync(id, cancellationToken: cancellationToken);`
	`452`	`+ }`
`434`	`453`	`}`