public virtual async Task HandleEventAsync(EntityDeletedEventData <File> eventData)
{
if (_configurationProvider.Get(eventData.Entity.FileContainerName).RetainDeletedBlobs)
{
return;
}
if (await _fileRepository.FirstOrDefaultAsync(eventData.Entity.FileContainerName, eventData.Entity.BlobName) == null)
{
await _fileManager.DeleteBlobAsync(eventData.Entity);
}
}
public void Should_Property_Set_And_Get_Options_For_Different_Containers()
{
var testContainer1Config = _configurationProvider.Get <TestContainer1>();
Assert.Equal(nameof(FakeFileProvider1), testContainer1Config.Provider);
Assert.Equal("TestValue1", testContainer1Config.GetConfigurationOrDefault <string>("TestConfig1"));
Assert.Equal("TestValueDefault", testContainer1Config.GetConfigurationOrDefault <string>("TestConfigDefault"));
var testContainer2Config = _configurationProvider.Get <TestContainer2>();
Assert.Equal(nameof(FakeFileProvider2), testContainer2Config.Provider);
Assert.Equal("TestValue2", testContainer2Config.GetConfigurationOrDefault <string>("TestConfig2"));
Assert.Equal("TestValueDefault", testContainer2Config.GetConfigurationOrDefault <string>("TestConfigDefault"));
}
public virtual async Task <File> CreateAsync(string fileContainerName, Guid?ownerUserId, string fileName,
string mimeType, FileType fileType, File parent, byte[] fileContent)
{
Check.NotNullOrWhiteSpace(fileContainerName, nameof(File.FileContainerName));
Check.NotNullOrWhiteSpace(fileName, nameof(File.FileName));
var configuration = _configurationProvider.Get(fileContainerName);
CheckFileName(fileName, configuration);
CheckDirectoryHasNoFileContent(fileType, fileContent);
var hashString = _fileContentHashProvider.GetHashString(fileContent);
string blobName = null;
if (fileType == FileType.RegularFile)
{
var existingFile = await _fileRepository.FirstOrDefaultAsync(fileContainerName, hashString, fileContent.LongLength);
if (existingFile != null)
{
Check.NotNullOrWhiteSpace(existingFile.BlobName, nameof(existingFile.BlobName));
blobName = existingFile.BlobName;
}
else
{
blobName = await _fileBlobNameGenerator.CreateAsync(fileType, fileName, parent, mimeType,
configuration.AbpBlobDirectorySeparator);
}
}
if (configuration.EnableAutoRename)
{
if (await IsFileExistAsync(fileName, parent?.Id, fileContainerName, ownerUserId))
{
fileName = await _fileRepository.GetFileNameWithNextSerialNumberAsync(fileName, parent?.Id,
fileContainerName, ownerUserId);
}
}
await CheckFileNotExistAsync(fileName, parent?.Id, fileContainerName, ownerUserId);
var file = new File(GuidGenerator.Create(), CurrentTenant.Id, parent, fileContainerName, fileName, mimeType,
fileType, 0, fileContent?.LongLength ?? 0, hashString, blobName, ownerUserId);
return(file);
}
public virtual async Task <CreateFileOutput> CreateAsync(CreateFileInput input)
{
var configuration = _configurationProvider.Get(input.FileContainerName);
CheckFileSize(new Dictionary <string, long> {
{ input.FileName, input.Content?.LongLength ?? 0 }
}, configuration);
if (input.FileType == FileType.RegularFile)
{
CheckFileExtension(new[] { Path.GetExtension(input.FileName) }, configuration);
}
var parent = await TryGetEntityByNullableIdAsync(input.ParentId);
var file = await _fileManager.CreateAsync(input.FileContainerName, input.OwnerUserId, input.FileName,
input.MimeType, input.FileType, parent, input.Content);
await AuthorizationService.CheckAsync(CreateFileOperationInfoModel(file),
new OperationAuthorizationRequirement { Name = FileManagementPermissions.File.Create });
await _repository.InsertAsync(file);
await _fileManager.TrySaveBlobAsync(file, input.Content);
return(await MapToCreateOutputDtoAsync(file));
}
protected virtual async Task BasicCheckAsync(string permissionName, AuthorizationHandlerContext context,
OperationAuthorizationRequirement requirement, FileOperationInfoModel resource)
{
await SetFailIfUserDoesNotHavePermissionAsync(permissionName, context);
await SetSucceedIfUserIsManagerAsync(context, requirement);
var configuration = _configurationProvider.Get(resource.FileContainerName);
await SetFailIfUserIsNotPersonalContainerOwnerAsync(configuration, context, resource);
}
public void Aliyun_Default_Configuration_Test()
{
var configuration = _configurationProvider.Get <DefaultContainer>();
Assert.Equal("Aliyun", configuration.Provider);
Assert.False(configuration.IsMultiTenant);
Assert.True(configuration.HttpAccess);
var aliyunConfiguration = configuration.GetAliyunConfiguration();
Assert.Equal("oss-cn-hangzhou", aliyunConfiguration.RegionId);
Assert.Equal("oss-cn-hangzhou.aliyuncs.com", aliyunConfiguration.Endpoint);
Assert.Equal("aliyun-bucket", aliyunConfiguration.BucketName);
Assert.Equal("AccessKeyId", aliyunConfiguration.AccessKeyId);
Assert.Equal("AccessKeySecret", aliyunConfiguration.AccessKeySecret);
Assert.False(aliyunConfiguration.UseSecurityTokenService);
Assert.True(aliyunConfiguration.RoleArn.IsNullOrWhiteSpace());
Assert.True(aliyunConfiguration.RoleSessionName.IsNullOrWhiteSpace());
Assert.Equal(100, aliyunConfiguration.DurationSeconds);
Assert.True(aliyunConfiguration.Policy.IsNullOrWhiteSpace());
Assert.True(aliyunConfiguration.CreateContainerIfNotExists);
Assert.Equal("key1", aliyunConfiguration.TemporaryCredentialsCacheKey);
}
public static FileContainerConfiguration Get <TContainer>(
this IFileContainerConfigurationProvider configurationProvider)
{
return(configurationProvider.Get(FileContainerNameAttribute.GetContainerName <TContainer>()));
}
