IlyaSobolev/DocSpace-buildtools
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactoring async methods

Browse Source
This commit is contained in:
Vashchuk Nikita 2022-02-15 16:20:06 +03:00
parent 41d994ca32
commit b17119b711
25 changed files with 484 additions and 276 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
common/ASC.Data.Storage/ChunkedUploader/CommonChunkedUploadSessionHolder.cs
View File

@ -88,24 +88,29 @@ namespace ASC.Core.ChunkedUploader
await DataStore.DeleteAsync(Domain, GetPathWithId(s.Id));
}
public async Task<Stream> GetStreamAsync(string sessionId)
public Task<Stream> GetStreamAsync(string sessionId)
{
return await DataStore.GetReadStreamAsync(Domain, GetPathWithId(sessionId));
return DataStore.GetReadStreamAsync(Domain, GetPathWithId(sessionId));
}
public async Task InitAsync(CommonChunkedUploadSession chunkedUploadSession)
public Task InitAsync(CommonChunkedUploadSession chunkedUploadSession)
{
if (chunkedUploadSession.BytesTotal < MaxChunkUploadSize)
{
chunkedUploadSession.UseChunks = false;
return;
return Task.CompletedTask;
}
return internalInitAsync(chunkedUploadSession);
}
private async Task internalInitAsync(CommonChunkedUploadSession chunkedUploadSession)
{
var tempPath = Guid.NewGuid().ToString();
var uploadId = await DataStore.InitiateChunkedUploadAsync(Domain, tempPath);
chunkedUploadSession.TempPath = tempPath;
chunkedUploadSession.UploadId = uploadId;
chunkedUploadSession.UploadId = uploadId;
}
public async Task FinalizeAsync(CommonChunkedUploadSession uploadSession)

27
common/ASC.Data.Storage/S3/S3Storage.cs
View File

@ -286,33 +286,15 @@ namespace ASC.Data.Storage.S3
return await GetUriAsync(domain, path);
}
private void InvalidateCloudFront(params string[] paths)
private Task InvalidateCloudFrontAsync(params string[] paths)
{
if (!_revalidateCloudFront || string.IsNullOrEmpty(_distributionId)) return;
if (!_revalidateCloudFront || string.IsNullOrEmpty(_distributionId)) return Task.CompletedTask;
using var cfClient = GetCloudFrontClient();
var invalidationRequest = new CreateInvalidationRequest
{
DistributionId = _distributionId,
InvalidationBatch = new InvalidationBatch
{
CallerReference = Guid.NewGuid().ToString(),
Paths = new Paths
{
Items = paths.ToList(),
Quantity = paths.Length
}
}
};
cfClient.CreateInvalidationAsync(invalidationRequest).Wait();
return InternalInvalidateCloudFrontAsync(paths);
}
private async Task InvalidateCloudFrontAsync(params string[] paths)
private async Task InternalInvalidateCloudFrontAsync(params string[] paths)
{
if (!_revalidateCloudFront || string.IsNullOrEmpty(_distributionId)) return;
using var cfClient = GetCloudFrontClient();
var invalidationRequest = new CreateInvalidationRequest
{
@ -332,6 +314,7 @@ namespace ASC.Data.Storage.S3
await cfClient.CreateInvalidationAsync(invalidationRequest);
}
public override Task<Uri> SaveAsync(string domain, string path, Stream stream)
{
return SaveAsync(domain, path, stream, string.Empty, string.Empty);

13
products/ASC.Files/Core/Core/Dao/TeamlabDao/AbstractDao.cs
View File

@ -140,14 +140,19 @@ namespace ASC.Files.Core.Data
await FilesDbContext.SaveChangesAsync();
}
protected async ValueTask<object> MappingIDAsync(object id, bool saveIfNotExist = false)
protected ValueTask<object> MappingIDAsync(object id, bool saveIfNotExist = false)
{
if (id == null) return null;
if (id == null) return ValueTask.FromResult<object>(null);
var isNumeric = int.TryParse(id.ToString(), out var n);
if (isNumeric) return n;
if (isNumeric) return ValueTask.FromResult<object>(n);
return InternalMappingIDAsync(id, saveIfNotExist);
}
private async ValueTask<object> InternalMappingIDAsync(object id, bool saveIfNotExist = false)
{
object result;
if (id.ToString().StartsWith("sbox")
@ -179,7 +184,7 @@ namespace ASC.Files.Core.Data
await FilesDbContext.AddOrUpdateAsync(r => r.ThirdpartyIdMapping, newItem);
}
return result;
return result;
}
protected ValueTask<object> MappingIDAsync(object id)

78
products/ASC.Files/Core/Core/Dao/TeamlabDao/FileDao.cs
View File

@ -150,10 +150,15 @@ namespace ASC.Files.Core.Data
.ConfigureAwait(false));
}
public async Task<File<int>> GetFileAsync(int parentId, string title)
public Task<File<int>> GetFileAsync(int parentId, string title)
{
if (string.IsNullOrEmpty(title)) throw new ArgumentNullException(title);
return InternalGetFileAsync(parentId, title);
}
private async Task<File<int>> InternalGetFileAsync(int parentId, string title)
{
var query = GetFileQuery(r => r.Title == title && r.CurrentVersion && r.FolderId == parentId)
.AsNoTracking()
.OrderBy(r => r.CreateOn);
@ -364,7 +369,7 @@ namespace ASC.Files.Core.Data
return SaveFileAsync(file, fileStream, true);
}
public async Task<File<int>> SaveFileAsync(File<int> file, Stream fileStream, bool checkQuota = true)
public Task<File<int>> SaveFileAsync(File<int> file, Stream fileStream, bool checkQuota = true)
{
if (file == null)
{
@ -376,7 +381,11 @@ namespace ASC.Files.Core.Data
{
throw FileSizeComment.GetFileSizeException(maxChunkedUploadSize);
}
return InternalSaveFileAsync(file, fileStream, checkQuota);
}
private async Task<File<int>> InternalSaveFileAsync(File<int> file, Stream fileStream, bool checkQuota = true)
{
if (checkQuota && CoreBaseSettings.Personal && SetupInfo.IsVisibleSettings("PersonalMaxSpace"))
{
var personalMaxSpace = CoreConfiguration.PersonalMaxSpace(SettingsManager);
@ -514,7 +523,7 @@ namespace ASC.Files.Core.Data
return await GetFileAsync(file.ID).ConfigureAwait(false);
}
public async Task<File<int>> ReplaceFileVersionAsync(File<int> file, Stream fileStream)
public Task<File<int>> ReplaceFileVersionAsync(File<int> file, Stream fileStream)
{
if (file == null) throw new ArgumentNullException(nameof(file));
if (file.ID == default) throw new ArgumentException("No file id or folder id toFolderId determine provider");
@ -525,7 +534,11 @@ namespace ASC.Files.Core.Data
{
throw FileSizeComment.GetFileSizeException(maxChunkedUploadSize);
}
return InternalReplaceFileVersionAsync(file, fileStream);
}
private async Task<File<int>> InternalReplaceFileVersionAsync(File<int> file, Stream fileStream)
{
if (CoreBaseSettings.Personal && SetupInfo.IsVisibleSettings("PersonalMaxSpace"))
{
var personalMaxSpace = CoreConfiguration.PersonalMaxSpace(SettingsManager);
@ -624,12 +637,17 @@ namespace ASC.Files.Core.Data
return await GetFileAsync(file.ID).ConfigureAwait(false);
}
private async Task DeleteVersionAsync(File<int> file)
private Task DeleteVersionAsync(File<int> file)
{
if (file == null
|| file.ID == default
|| file.Version <= 1) return;
|| file.Version <= 1) return Task.CompletedTask;
return InternalDeleteVersionAsync(file);
}
private async Task InternalDeleteVersionAsync(File<int> file)
{
var toDelete = await Query(FilesDbContext.Files)
.FirstOrDefaultAsync(r => r.Id == file.ID && r.Version == file.Version)
.ConfigureAwait(false);
@ -653,7 +671,7 @@ namespace ASC.Files.Core.Data
await GlobalStore.GetStore().DeleteDirectoryAsync(GetUniqFileVersionPath(file.ID, file.Version));
}
private async Task SaveFileStreamAsync(File<int> file, Stream stream)
private async Task SaveFileStreamAsync(File<int> file, Stream stream)
{
await GlobalStore.GetStore().SaveAsync(string.Empty, GetUniqFilePath(file), stream, file.Title);
}
@ -663,9 +681,15 @@ namespace ASC.Files.Core.Data
return DeleteFileAsync(fileId, true);
}
private async Task DeleteFileAsync(int fileId, bool deleteFolder)
private Task DeleteFileAsync(int fileId, bool deleteFolder)
{
if (fileId == default) return Task.CompletedTask;
return internalDeleteFileAsync(fileId, deleteFolder);
}
private async Task internalDeleteFileAsync(int fileId, bool deleteFolder)
{
if (fileId == default) return;
using var tx = await FilesDbContext.Database.BeginTransactionAsync().ConfigureAwait(false);
var fromFolders = Query(FilesDbContext.Files)
@ -748,10 +772,15 @@ namespace ASC.Files.Core.Data
throw new NotImplementedException();
}
public async Task<int> MoveFileAsync(int fileId, int toFolderId)
public Task<int> MoveFileAsync(int fileId, int toFolderId)
{
if (fileId == default) return default;
if (fileId == default) return Task.FromResult<int>(default);
return InternalMoveFileAsync(fileId, toFolderId);
}
private async Task<int> InternalMoveFileAsync(int fileId, int toFolderId)
{
List<DbFile> toUpdate;
var trashIdTask = GlobalFolder.GetFolderTrashAsync<int>(DaoFactory);
@ -788,7 +817,7 @@ namespace ASC.Files.Core.Data
await RecalculateFilesCountAsync(toFolderId).ConfigureAwait(false);
}
var parentFoldersTask =
var parentFoldersTask =
FilesDbContext.Tree
.AsQueryable()
.Where(r => r.FolderId == toFolderId)
@ -1085,10 +1114,15 @@ namespace ASC.Files.Core.Data
return FilesDbContext.SaveChangesAsync();
}
public async Task<List<File<int>>> GetFilesAsync(IEnumerable<int> parentIds, FilterType filterType, bool subjectGroup, Guid subjectID, string searchText, bool searchInContent)
public Task<List<File<int>>> GetFilesAsync(IEnumerable<int> parentIds, FilterType filterType, bool subjectGroup, Guid subjectID, string searchText, bool searchInContent)
{
if (parentIds == null || !parentIds.Any() || filterType == FilterType.FoldersOnly) return new List<File<int>>();
if (parentIds == null || !parentIds.Any() || filterType == FilterType.FoldersOnly) return Task.FromResult(new List<File<int>>());
return InternalGetFilesAsync(parentIds, filterType, subjectGroup, subjectID, searchText, searchInContent);
}
private async Task<List<File<int>>> InternalGetFilesAsync(IEnumerable<int> parentIds, FilterType filterType, bool subjectGroup, Guid subjectID, string searchText, bool searchInContent)
{
var q = GetFileQuery(r => r.CurrentVersion)
.AsNoTracking()
.Join(FilesDbContext.Tree, a => a.FolderId, t => t.FolderId, (file, tree) => new { file, tree })
@ -1181,12 +1215,17 @@ namespace ASC.Files.Core.Data
private const string DiffTitle = "diff.zip";
public async Task SaveEditHistoryAsync(File<int> file, string changes, Stream differenceStream)
public Task SaveEditHistoryAsync(File<int> file, string changes, Stream differenceStream)
{
if (file == null) throw new ArgumentNullException(nameof(file));
if (string.IsNullOrEmpty(changes)) throw new ArgumentNullException(nameof(changes));
if (differenceStream == null) throw new ArgumentNullException(nameof(differenceStream));
return InternalSaveEditHistoryAsync(file, changes, differenceStream);
}
private async Task InternalSaveEditHistoryAsync(File<int> file, string changes, Stream differenceStream)
{
var toUpdateTask = Query(FilesDbContext.Files)
.Where(r => r.Id == file.ID)
.Where(r => r.Version == file.Version)
@ -1232,8 +1271,8 @@ namespace ASC.Files.Core.Data
item.ChangesString = r.Changes;
item.Key = documentServiceHelper.GetDocKey(item.ID, item.Version, TenantUtil.DateTimeFromUtc(r.CreateOn));
return item;
})
return item;
})
.ToList();
}
@ -1309,10 +1348,15 @@ namespace ASC.Files.Core.Data
private const string ThumbnailTitle = "thumb";
public async Task SaveThumbnailAsync(File<int> file, Stream thumbnail)
public Task SaveThumbnailAsync(File<int> file, Stream thumbnail)
{
if (file == null) throw new ArgumentNullException(nameof(file));
return InternalSaveThumbnailAsync(file, thumbnail);
}
private async Task InternalSaveThumbnailAsync(File<int> file, Stream thumbnail)
{
var toUpdate = await FilesDbContext.Files
.AsQueryable()
.FirstOrDefaultAsync(r => r.Id == file.ID && r.Version == file.Version && r.TenantId == TenantID)

35
products/ASC.Files/Core/Core/Dao/TeamlabDao/FolderDao.cs
View File

@ -122,10 +122,15 @@ namespace ASC.Files.Core.Data
return ToFolder(await FromQueryWithShared(query).Take(1).SingleOrDefaultAsync().ConfigureAwait(false));
}
public async Task<Folder<int>> GetFolderAsync(string title, int parentId)
public Task<Folder<int>> GetFolderAsync(string title, int parentId)
{
if (string.IsNullOrEmpty(title)) throw new ArgumentNullException(title);
return InternalGetFolderAsync(title, parentId);
}
private async Task<Folder<int>> InternalGetFolderAsync(string title, int parentId)
{
var query = GetFolderQuery(r => r.Title == title && r.ParentId == parentId).AsNoTracking()
.OrderBy(r => r.CreateOn);
@ -296,10 +301,15 @@ namespace ASC.Files.Core.Data
return SaveFolderAsync(folder, null);
}
public async Task<int> SaveFolderAsync(Folder<int> folder, IDbContextTransaction transaction)
public Task<int> SaveFolderAsync(Folder<int> folder, IDbContextTransaction transaction)
{
if (folder == null) throw new ArgumentNullException(nameof(folder));
return InternalSaveFolderAsync(folder, transaction);
}
public async Task<int> InternalSaveFolderAsync(Folder<int> folder, IDbContextTransaction transaction)
{
folder.Title = Global.ReplaceInvalidCharsAndTruncate(folder.Title);
folder.ModifiedOn = TenantUtil.DateTimeNow();
@ -408,10 +418,15 @@ namespace ASC.Files.Core.Data
.AnyAsync(r => r.Id == folderId);
}
public async Task DeleteFolderAsync(int id)
public Task DeleteFolderAsync(int id)
{
if (id == default) throw new ArgumentNullException("folderId");
return InternalDeleteFolderAsync(id);
}
private async Task InternalDeleteFolderAsync(int id)
{
using var tx = FilesDbContext.Database.BeginTransaction();
var subfolders =
await FilesDbContext.Tree
@ -847,11 +862,16 @@ namespace ASC.Files.Core.Data
return fromQuery.Select(ToFolder);
}
public async Task<IEnumerable<int>> GetFolderIDsAsync(string module, string bunch, IEnumerable<string> data, bool createIfNotExists)
public Task<IEnumerable<int>> GetFolderIDsAsync(string module, string bunch, IEnumerable<string> data, bool createIfNotExists)
{
if (string.IsNullOrEmpty(module)) throw new ArgumentNullException(nameof(module));
if (string.IsNullOrEmpty(bunch)) throw new ArgumentNullException(nameof(bunch));
return InternalGetFolderIDsAsync(module, bunch, data, createIfNotExists);
}
private async Task<IEnumerable<int>> InternalGetFolderIDsAsync(string module, string bunch, IEnumerable<string> data, bool createIfNotExists)
{
var keys = data.Select(id => $"{module}/{bunch}/{id}").ToArray();
var folderIdsDictionary = await Query(FilesDbContext.BunchObjects)
@ -932,11 +952,16 @@ namespace ASC.Files.Core.Data
return folderIds;
}
public async Task<int> GetFolderIDAsync(string module, string bunch, string data, bool createIfNotExists)
public Task<int> GetFolderIDAsync(string module, string bunch, string data, bool createIfNotExists)
{
if (string.IsNullOrEmpty(module)) throw new ArgumentNullException(nameof(module));
if (string.IsNullOrEmpty(bunch)) throw new ArgumentNullException(nameof(bunch));
return InternalGetFolderIDAsync(module, bunch, data, createIfNotExists);
}
private async Task<int> InternalGetFolderIDAsync(string module, string bunch, string data, bool createIfNotExists)
{
var key = $"{module}/{bunch}/{data}";
var folderId = await Query(FilesDbContext.BunchObjects)
.Where(r => r.RightNode == key)

53
products/ASC.Files/Core/Core/Dao/TeamlabDao/SecurityDao.cs
View File

@ -192,10 +192,15 @@ namespace ASC.Files.Core.Data
return FromQueryAsync(q);
}
public async Task<IEnumerable<FileShareRecord>> GetPureShareRecordsAsync(IEnumerable<FileEntry<T>> entries)
public Task<IEnumerable<FileShareRecord>> GetPureShareRecordsAsync(IEnumerable<FileEntry<T>> entries)
{
if (entries == null) return new List<FileShareRecord>();
if (entries == null) return Task.FromResult<IEnumerable<FileShareRecord>>(new List<FileShareRecord>());
return InternalGetPureShareRecordsAsync(entries);
}
private async Task<IEnumerable<FileShareRecord>> InternalGetPureShareRecordsAsync(IEnumerable<FileEntry<T>> entries)
{
var files = new List<string>();
var folders = new List<string>();
@ -204,13 +209,18 @@ namespace ASC.Files.Core.Data
await SelectFilesAndFoldersForShareAsync(entry, files, folders, null);
}
return await GetPureShareRecordsDbAsync(files, folders);
return await GetPureShareRecordsDbAsync(files, folders);
}
public async Task<IEnumerable<FileShareRecord>> GetPureShareRecordsAsync(IAsyncEnumerable<FileEntry<T>> entries)
public Task<IEnumerable<FileShareRecord>> GetPureShareRecordsAsync(IAsyncEnumerable<FileEntry<T>> entries)
{
if (entries == null) return new List<FileShareRecord>();
if (entries == null) return Task.FromResult<IEnumerable<FileShareRecord>>(new List<FileShareRecord>());
return InternalGetPureShareRecordsAsync(entries);
}
private async Task<IEnumerable<FileShareRecord>> InternalGetPureShareRecordsAsync(IAsyncEnumerable<FileEntry<T>> entries)
{
var files = new List<string>();
var folders = new List<string>();
@ -219,19 +229,24 @@ namespace ASC.Files.Core.Data
await SelectFilesAndFoldersForShareAsync(entry, files, folders, null);
}
return await GetPureShareRecordsDbAsync(files, folders);
return await GetPureShareRecordsDbAsync(files, folders);
}
public async Task<IEnumerable<FileShareRecord>> GetPureShareRecordsAsync(FileEntry<T> entry)
public Task<IEnumerable<FileShareRecord>> GetPureShareRecordsAsync(FileEntry<T> entry)
{
if (entry == null) return new List<FileShareRecord>();
if (entry == null) return Task.FromResult<IEnumerable<FileShareRecord>>(new List<FileShareRecord>());
return InternalGetPureShareRecordsAsync(entry);
}
private async Task<IEnumerable<FileShareRecord>> InternalGetPureShareRecordsAsync(FileEntry<T> entry)
{
var files = new List<string>();
var folders = new List<string>();
await SelectFilesAndFoldersForShareAsync(entry, files, folders, null);
return await GetPureShareRecordsDbAsync(files, folders);
return await GetPureShareRecordsDbAsync(files, folders);
}
private async Task<IEnumerable<FileShareRecord>> GetPureShareRecordsDbAsync(List<string> files, List<string> folders)
@ -255,10 +270,15 @@ namespace ASC.Files.Core.Data
/// </summary>
/// <param name="entries"></param>
/// <returns></returns>
public async Task<IEnumerable<FileShareRecord>> GetSharesAsync(IEnumerable<FileEntry<T>> entries)
public Task<IEnumerable<FileShareRecord>> GetSharesAsync(IEnumerable<FileEntry<T>> entries)
{
if (entries == null) return new List<FileShareRecord>();
if (entries == null) return Task.FromResult<IEnumerable<FileShareRecord>>(new List<FileShareRecord>());
return InternalGetSharesAsync(entries);
}
private async Task<IEnumerable<FileShareRecord>> InternalGetSharesAsync(IEnumerable<FileEntry<T>> entries)
{
var files = new List<string>();
var foldersInt = new List<int>();
@ -275,16 +295,21 @@ namespace ASC.Files.Core.Data
/// </summary>
/// <param name="entry"></param>
/// <returns></returns>
public async Task<IEnumerable<FileShareRecord>> GetSharesAsync(FileEntry<T> entry)
public Task<IEnumerable<FileShareRecord>> GetSharesAsync(FileEntry<T> entry)
{
if (entry == null) return new List<FileShareRecord>();
if (entry == null) return Task.FromResult<IEnumerable<FileShareRecord>>(new List<FileShareRecord>());
return InternalGetSharesAsync(entry);
}
public async Task<IEnumerable<FileShareRecord>> InternalGetSharesAsync(FileEntry<T> entry)
{
var files = new List<string>();
var foldersInt = new List<int>();
await SelectFilesAndFoldersForShareAsync(entry, files, null, foldersInt);
return await SaveFilesAndFoldersForShareAsync(files, foldersInt);
}
}
private async Task SelectFilesAndFoldersForShareAsync(FileEntry<T> entry, ICollection<string> files, ICollection<string> folders, ICollection<int> foldersInt)
{

32
products/ASC.Files/Core/Core/Dao/TeamlabDao/TagDao.cs
View File

@ -185,10 +185,15 @@ ctx.Tag
}
}
public async IAsyncEnumerable<Tag> GetTagsAsync(string[] names, TagType tagType)
public IAsyncEnumerable<Tag> GetTagsAsync(string[] names, TagType tagType)
{
if (names == null) throw new ArgumentNullException(nameof(names));
return InternalGetTagsAsync(names, tagType);
}
public async IAsyncEnumerable<Tag> InternalGetTagsAsync(string[] names, TagType tagType)
{
var q = Query(FilesDbContext.Tag)
.Join(FilesDbContext.TagLink, r => r.Id, l => l.TagId, (tag, link) => new TagLinkData { Tag = tag, Link = link })
.Where(r => r.Link.TenantId == r.Tag.TenantId)
@ -391,10 +396,15 @@ ctx.Tag
}
}
private async Task UpdateNewTagsInDbAsync(Tag tag, DateTime createOn)
private Task UpdateNewTagsInDbAsync(Tag tag, DateTime createOn)
{
if (tag == null) return;
if (tag == null) return Task.CompletedTask;
return InternalUpdateNewTagsInDbAsync(tag, createOn);
}
private async Task InternalUpdateNewTagsInDbAsync(Tag tag, DateTime createOn)
{
var forUpdate = Query(FilesDbContext.TagLink)
.Where(r => r.TagId == tag.Id)
.Where(r => r.EntryType == tag.EntryType)
@ -438,10 +448,15 @@ ctx.Tag
}
}
private async Task RemoveTagInDbAsync(Tag tag)
private Task RemoveTagInDbAsync(Tag tag)
{
if (tag == null) return;
if (tag == null) return Task.CompletedTask;
return InternalRemoveTagInDbAsync(tag);
}
private async Task InternalRemoveTagInDbAsync(Tag tag)
{
var id = await Query(FilesDbContext.Tag)
.Where(r => r.Name == tag.TagName &&
r.Owner == tag.Owner &&
@ -713,11 +728,16 @@ ctx.Tag
yield break;
}
public async IAsyncEnumerable<Tag> GetNewTagsAsync(Guid subject, Folder<T> parentFolder, bool deepSearch)
public IAsyncEnumerable<Tag> GetNewTagsAsync(Guid subject, Folder<T> parentFolder, bool deepSearch)
{
if (parentFolder == null || EqualityComparer<T>.Default.Equals(parentFolder.ID, default(T)))
throw new ArgumentException("folderId");
return InternalGetNewTagsAsync(subject, parentFolder, deepSearch);
}
private async IAsyncEnumerable<Tag> InternalGetNewTagsAsync(Guid subject, Folder<T> parentFolder, bool deepSearch)
{
var result = AsyncEnumerable.Empty<Tag>();
var monitorFolderIds = new object[] { parentFolder.ID }.ToAsyncEnumerable();

92
products/ASC.Files/Core/Core/FileStorageService.cs
View File

@ -400,11 +400,17 @@ namespace ASC.Web.Files.Services.WCFService
return new List<FileEntry>(entries);
}
public async Task<Folder<T>> CreateNewFolderAsync(T parentId, string title)
public Task<Folder<T>> CreateNewFolderAsync(T parentId, string title)
{
if (string.IsNullOrEmpty(title) || parentId == null) throw new ArgumentException();
return InternalCreateNewFolderAsync(parentId, title);
}
public async Task<Folder<T>> InternalCreateNewFolderAsync(T parentId, string title)
{
var folderDao = GetFolderDao();
var parent = await folderDao.GetFolderAsync(parentId);
ErrorIf(parent == null, FilesCommonResource.ErrorMassage_FolderNotFound);
ErrorIf(!await FileSecurity.CanCreateAsync(parent), FilesCommonResource.ErrorMassage_SecurityException_Create);
@ -560,10 +566,15 @@ namespace ASC.Web.Files.Services.WCFService
return new List<File<T>>(result);
}
public async Task<File<T>> CreateNewFileAsync<TTemplate>(FileModel<T, TTemplate> fileWrapper, bool enableExternalExt = false)
public Task<File<T>> CreateNewFileAsync<TTemplate>(FileModel<T, TTemplate> fileWrapper, bool enableExternalExt = false)
{
if (string.IsNullOrEmpty(fileWrapper.Title) || fileWrapper.ParentId == null) throw new ArgumentException();
return InternalCreateNewFileAsync(fileWrapper, enableExternalExt);
}
private async Task<File<T>> InternalCreateNewFileAsync<TTemplate>(FileModel<T, TTemplate> fileWrapper, bool enableExternalExt = false)
{
var fileDao = GetFileDao();
var folderDao = GetFolderDao();
@ -1197,11 +1208,16 @@ namespace ASC.Web.Files.Services.WCFService
return FileOperationsManager.MarkAsRead(AuthContext.CurrentAccount.ID, TenantManager.GetCurrentTenant(), foldersId, filesId);
}
public async Task<List<ThirdPartyParams>> GetThirdPartyAsync()
public Task<List<ThirdPartyParams>> GetThirdPartyAsync()
{
var providerDao = GetProviderDao();
if (providerDao == null) return new List<ThirdPartyParams>();
if (providerDao == null) return Task.FromResult(new List<ThirdPartyParams>());
return internalGetThirdPartyAsync(providerDao);
}
public async Task<List<ThirdPartyParams>> internalGetThirdPartyAsync(IProviderDao providerDao)
{
var providersInfo = await providerDao.GetProvidersInfoAsync().ToListAsync();
var resultList = providersInfo
@ -1217,32 +1233,43 @@ namespace ASC.Web.Files.Services.WCFService
return new List<ThirdPartyParams>(resultList.ToList());
}
public async Task<List<FileEntry>> GetThirdPartyFolderAsync(int folderType = 0)
public Task<List<FileEntry>> GetThirdPartyFolderAsync(int folderType = 0)
{
if (!FilesSettingsHelper.EnableThirdParty) return new List<FileEntry>();
if (!FilesSettingsHelper.EnableThirdParty) return Task.FromResult(new List<FileEntry>());
var providerDao = GetProviderDao();
if (providerDao == null) return new List<FileEntry>();
if (providerDao == null) return Task.FromResult(new List<FileEntry>());
return InternalGetThirdPartyFolderAsync(folderType, providerDao);
}
private async Task<List<FileEntry>> InternalGetThirdPartyFolderAsync(int folderType, IProviderDao providerDao)
{
var providersInfo = await providerDao.GetProvidersInfoAsync((FolderType)folderType).ToListAsync();
var folders = providersInfo.Select(providerInfo =>
{
var folder = EntryManager.GetFakeThirdpartyFolder(providerInfo);
folder.NewForMe = folder.RootFolderType == FolderType.COMMON ? 1 : 0;
return folder;
});
{
var folder = EntryManager.GetFakeThirdpartyFolder(providerInfo);
folder.NewForMe = folder.RootFolderType == FolderType.COMMON ? 1 : 0;
return folder;
});
return new List<FileEntry>(folders);
}
public async Task<Folder<T>> SaveThirdPartyAsync(ThirdPartyParams thirdPartyParams)
public Task<Folder<T>> SaveThirdPartyAsync(ThirdPartyParams thirdPartyParams)
{
var providerDao = GetProviderDao();
if (providerDao == null) return Task.FromResult<Folder<T>>(null);
return InternalSaveThirdPartyAsync(thirdPartyParams, providerDao);
}
private async Task<Folder<T>> InternalSaveThirdPartyAsync(ThirdPartyParams thirdPartyParams, IProviderDao providerDao)
{
var folderDaoInt = DaoFactory.GetFolderDao<int>();
var folderDao = GetFolderDao();
var providerDao = GetProviderDao();
if (providerDao == null) return null;
ErrorIf(thirdPartyParams == null, FilesCommonResource.ErrorMassage_BadRequest);
var parentFolder = await folderDaoInt.GetFolderAsync(thirdPartyParams.Corporate && !CoreBaseSettings.Personal ? await GlobalFolderHelper.FolderCommonAsync : GlobalFolderHelper.FolderMy);
@ -1315,11 +1342,16 @@ namespace ASC.Web.Files.Services.WCFService
return folder;
}
public async Task<object> DeleteThirdPartyAsync(string providerId)
public Task<object> DeleteThirdPartyAsync(string providerId)
{
var providerDao = GetProviderDao();
if (providerDao == null) return null;
if (providerDao == null) return Task.FromResult<object>(null);
return InternalDeleteThirdPartyAsync(providerId, providerDao);
}
private async Task<object> InternalDeleteThirdPartyAsync(string providerId, IProviderDao providerDao)
{
var curProviderId = Convert.ToInt32(providerId);
var providerInfo = await providerDao.GetProviderInfoAsync(curProviderId);
@ -1780,10 +1812,15 @@ namespace ASC.Web.Files.Services.WCFService
return favorite;
}
public async Task<List<FileEntry<T>>> AddToFavoritesAsync(IEnumerable<T> foldersId, IEnumerable<T> filesId)
public Task<List<FileEntry<T>>> AddToFavoritesAsync(IEnumerable<T> foldersId, IEnumerable<T> filesId)
{
if (UserManager.GetUsers(AuthContext.CurrentAccount.ID).IsVisitor(UserManager)) throw new SecurityException(FilesCommonResource.ErrorMassage_SecurityException);
return InternalAddToFavoritesAsync(foldersId, filesId);
}
private async Task<List<FileEntry<T>>> InternalAddToFavoritesAsync(IEnumerable<T> foldersId, IEnumerable<T> filesId)
{
var tagDao = GetTagDao();
var fileDao = GetFileDao();
var folderDao = GetFolderDao();
@ -1830,10 +1867,15 @@ namespace ASC.Web.Files.Services.WCFService
#region Templates Manager
public async Task<List<FileEntry<T>>> AddToTemplatesAsync(IEnumerable<T> filesId)
public Task<List<FileEntry<T>>> AddToTemplatesAsync(IEnumerable<T> filesId)
{
if (UserManager.GetUsers(AuthContext.CurrentAccount.ID).IsVisitor(UserManager)) throw new SecurityException(FilesCommonResource.ErrorMassage_SecurityException);
return InternalAddToTemplatesAsync(filesId);
}
private async Task<List<FileEntry<T>>> InternalAddToTemplatesAsync(IEnumerable<T> filesId)
{
var tagDao = GetTagDao();
var fileDao = GetFileDao();
var files = await fileDao.GetFilesAsync(filesId).ToListAsync();
@ -2007,10 +2049,16 @@ namespace ASC.Web.Files.Services.WCFService
return await securityDao.IsSharedAsync(file.ID, FileEntryType.File);
}
public async Task<List<MentionWrapper>> SharedUsersAsync(T fileId)
public Task<List<MentionWrapper>> SharedUsersAsync(T fileId)
{
if (!AuthContext.IsAuthenticated || CoreBaseSettings.Personal)
return null;
return Task.FromResult<List<MentionWrapper>>(null);
return InternalSharedUsersAsync(fileId);
}
public async Task<List<MentionWrapper>> InternalSharedUsersAsync(T fileId)
{
FileEntry<T> file;
var fileDao = GetFileDao();

13
products/ASC.Files/Core/Core/Security/FileSecurity.cs
View File

@ -353,15 +353,20 @@ namespace ASC.Files.Core.Security
return entry.Select(r => new Tuple<FileEntry<T>, bool>(r, filtres.Any(a => a.ID.Equals(r.ID)))).ToList();
}
private async Task<IEnumerable<FileEntry<T>>> FilterAsync<T>(IEnumerable<FileEntry<T>> entries, FilesSecurityActions action, Guid userId, IEnumerable<FileShareRecord> shares = null)
private Task<IEnumerable<FileEntry<T>>> FilterAsync<T>(IEnumerable<FileEntry<T>> entries, FilesSecurityActions action, Guid userId, IEnumerable<FileShareRecord> shares = null)
{
if (entries == null || !entries.Any()) return Enumerable.Empty<FileEntry<T>>();
if (entries == null || !entries.Any()) return Task.FromResult(Enumerable.Empty<FileEntry<T>>());
var user = UserManager.GetUsers(userId);
var isOutsider = user.IsOutsider(UserManager);
if (isOutsider && action != FilesSecurityActions.Read) return Enumerable.Empty<FileEntry<T>>();
if (isOutsider && action != FilesSecurityActions.Read) return Task.FromResult(Enumerable.Empty<FileEntry<T>>());
return InternalFilterAsync(entries, action, userId, shares, user, isOutsider);
}
private async Task<IEnumerable<FileEntry<T>>> InternalFilterAsync<T>(IEnumerable<FileEntry<T>> entries, FilesSecurityActions action, Guid userId, IEnumerable<FileShareRecord> shares, UserInfo user, bool isOutsider)
{
entries = entries.Where(f => f != null).ToList();
var result = new List<FileEntry<T>>(entries.Count());

7
products/ASC.Files/Core/Core/Thirdparty/Box/BoxFileDao.cs vendored
View File

@ -281,11 +281,16 @@ namespace ASC.Files.Thirdparty.Box
return Task.FromResult(false);
}
public async Task<File<string>> SaveFileAsync(File<string> file, Stream fileStream)
public Task<File<string>> SaveFileAsync(File<string> file, Stream fileStream)
{
if (file == null) throw new ArgumentNullException(nameof(file));
if (fileStream == null) throw new ArgumentNullException(nameof(fileStream));
return InternalSaveFileAsync(file, fileStream);
}
private async Task<File<string>> InternalSaveFileAsync(File<string> file, Stream fileStream)
{
BoxFile newBoxFile = null;
var storage = await ProviderInfo.StorageAsync;

10
products/ASC.Files/Core/Core/Thirdparty/Box/BoxFolderDao.cs vendored
View File

@ -186,9 +186,15 @@ namespace ASC.Files.Thirdparty.Box
}
public async Task<string> SaveFolderAsync(Folder<string> folder)
public Task<string> SaveFolderAsync(Folder<string> folder)
{
if (folder == null) throw new ArgumentNullException(nameof(folder));
return InternalSaveFolderAsync(folder);
}
private async Task<string> InternalSaveFolderAsync(Folder<string> folder)
{
if (folder == null) throw new ArgumentNullException(nameof(folder));
if (folder.ID != null)
{
return await RenameFolderAsync(folder, folder.Title).ConfigureAwait(false);

16
products/ASC.Files/Core/Core/Thirdparty/Box/BoxProviderInfo.cs vendored
View File

@ -187,10 +187,15 @@ namespace ASC.Files.Thirdparty.Box
ServiceProvider = serviceProvider;
}
internal async Task<BoxStorage> CreateStorageAsync(OAuth20Token token, int id)
internal Task<BoxStorage> CreateStorageAsync(OAuth20Token token, int id)
{
if (Storage != null && Storage.IsOpened) return Storage;
if (Storage != null && Storage.IsOpened) return Task.FromResult(Storage);
return InternalCreateStorageAsync(token, id);
}
private async Task<BoxStorage> InternalCreateStorageAsync(OAuth20Token token, int id)
{
var boxStorage = new BoxStorage(TempStream);
await CheckTokenAsync(token, id).ConfigureAwait(false);
@ -198,9 +203,14 @@ namespace ASC.Files.Thirdparty.Box
return Storage = boxStorage;
}
private async Task CheckTokenAsync(OAuth20Token token, int id)
private Task CheckTokenAsync(OAuth20Token token, int id)
{
if (token == null) throw new UnauthorizedAccessException("Cannot create Box session with given token");
return InternalCheckTokenAsync(token, id);
}
private async Task InternalCheckTokenAsync(OAuth20Token token, int id)
{
if (token.IsExpired)
{
token = OAuth20TokenHelper.RefreshToken<BoxLoginProvider>(ConsumerFactory, token);

7
products/ASC.Files/Core/Core/Thirdparty/Box/BoxStorage.cs vendored
View File

@ -121,10 +121,15 @@ namespace ASC.Files.Thirdparty.Box
return folderItems.Entries;
}
public async Task<Stream> DownloadStreamAsync(BoxFile file, int offset = 0)
public Task<Stream> DownloadStreamAsync(BoxFile file, int offset = 0)
{
if (file == null) throw new ArgumentNullException(nameof(file));
return InternalDownloadStreamAsync(file, offset);
}
public async Task<Stream> InternalDownloadStreamAsync(BoxFile file, int offset = 0)
{
if (offset > 0 && file.Size.HasValue)
{
return await _boxClient.FilesManager.DownloadAsync(file.Id, startOffsetInBytes: offset, endOffsetInBytes: (int)file.Size - 1);

18
products/ASC.Files/Core/Core/Thirdparty/Dropbox/DropboxFileDao.cs vendored
View File

@ -285,11 +285,16 @@ namespace ASC.Files.Thirdparty.Dropbox
return Task.FromResult(false);
}
public async Task<File<string>> SaveFileAsync(File<string> file, Stream fileStream)
public Task<File<string>> SaveFileAsync(File<string> file, Stream fileStream)
{
if (file == null) throw new ArgumentNullException(nameof(file));
if (fileStream == null) throw new ArgumentNullException(nameof(fileStream));
return InternalSaveFileAsync(file, fileStream);
}
private async Task<File<string>> InternalSaveFileAsync(File<string> file, Stream fileStream)
{
FileMetadata newDropboxFile = null;
if (file.ID != null)
@ -368,7 +373,7 @@ namespace ASC.Files.Thirdparty.Dropbox
if (!(dropboxFile is ErrorFile))
{
ProviderInfo.Storage.DeleteItem(dropboxFile);
await ProviderInfo.Storage.DeleteItemAsync(dropboxFile);
}
await ProviderInfo.CacheResetAsync(MakeDropboxPath(dropboxFile), true).ConfigureAwait(false);
@ -518,11 +523,16 @@ namespace ASC.Files.Thirdparty.Dropbox
return file;
}
public async Task<ChunkedUploadSession<string>> CreateUploadSessionAsync(File<string> file, long contentLength)
public Task<ChunkedUploadSession<string>> CreateUploadSessionAsync(File<string> file, long contentLength)
{
if (SetupInfo.ChunkUploadSize > contentLength)
return new ChunkedUploadSession<string>(RestoreIds(file), contentLength) { UseChunks = false };
return Task.FromResult(new ChunkedUploadSession<string>(RestoreIds(file), contentLength) { UseChunks = false });
return InternalCreateUploadSessionAsync(file, contentLength);
}
private async Task<ChunkedUploadSession<string>> InternalCreateUploadSessionAsync(File<string> file, long contentLength)
{
var uploadSession = new ChunkedUploadSession<string>(file, contentLength);
var dropboxSession = await ProviderInfo.Storage.CreateResumableSessionAsync().ConfigureAwait(false);

10
products/ASC.Files/Core/Core/Thirdparty/Dropbox/DropboxFolderDao.cs vendored
View File

@ -186,9 +186,15 @@ namespace ASC.Files.Thirdparty.Dropbox
return path;
}
public async Task<string> SaveFolderAsync(Folder<string> folder)
public Task<string> SaveFolderAsync(Folder<string> folder)
{
if (folder == null) throw new ArgumentNullException(nameof(folder));
return InternalSaveFolderAsync(folder);
}
public async Task<string> InternalSaveFolderAsync(Folder<string> folder)
{
if (folder == null) throw new ArgumentNullException(nameof(folder));
if (folder.ID != null)
{
return await RenameFolderAsync(folder, folder.Title).ConfigureAwait(false);

140
products/ASC.Files/Core/Core/Thirdparty/Dropbox/DropboxStorage.cs vendored
View File

@ -73,11 +73,6 @@ namespace ASC.Files.Thirdparty.Dropbox
public string MakeDropboxPath(string parentPath, string name)
{
return (parentPath ?? "") + "/" + (name ?? "");
}
public long GetUsedSpace()
{
return (long)dropboxClient.Users.GetSpaceUsageAsync().Result.Used;
}
public async Task<long> GetUsedSpaceAsync()
@ -85,34 +80,19 @@ namespace ASC.Files.Thirdparty.Dropbox
var spaceUsage = await dropboxClient.Users.GetSpaceUsageAsync();
return (long)spaceUsage.Used;
}
public FolderMetadata GetFolder(string folderPath)
public Task<FolderMetadata> GetFolderAsync(string folderPath)
{
if (string.IsNullOrEmpty(folderPath) || folderPath == "/")
{
return new FolderMetadata(string.Empty, "/");
}
try
{
return dropboxClient.Files.GetMetadataAsync(folderPath).Result.AsFolder;
}
catch (AggregateException ex)
{
if (ex.InnerException is ApiException<GetMetadataError>
&& ex.InnerException.Message.StartsWith("path/not_found/"))
{
return null;
}
throw;
return Task.FromResult(new FolderMetadata(string.Empty, "/"));
}
return InternalGetFolderAsync(folderPath);
}
public async Task<FolderMetadata> GetFolderAsync(string folderPath)
public async Task<FolderMetadata> InternalGetFolderAsync(string folderPath)
{
if (string.IsNullOrEmpty(folderPath) || folderPath == "/")
{
return new FolderMetadata(string.Empty, "/");
}
try
{
var metadata = await dropboxClient.Files.GetMetadataAsync(folderPath);
@ -127,35 +107,20 @@ namespace ASC.Files.Thirdparty.Dropbox
}
throw;
}
}
public FileMetadata GetFile(string filePath)
{
if (string.IsNullOrEmpty(filePath) || filePath == "/")
{
return null;
}
try
{
return dropboxClient.Files.GetMetadataAsync(filePath).Result.AsFile;
}
catch (AggregateException ex)
{
if (ex.InnerException is ApiException<GetMetadataError>
&& ex.InnerException.Message.StartsWith("path/not_found/"))
{
return null;
}
throw;
}
}
public async ValueTask<FileMetadata> GetFileAsync(string filePath)
public ValueTask<FileMetadata> GetFileAsync(string filePath)
{
if (string.IsNullOrEmpty(filePath) || filePath == "/")
{
return null;
}
return ValueTask.FromResult<FileMetadata>(null);
}
return InternalGetFileAsync(filePath);
}
private async ValueTask<FileMetadata> InternalGetFileAsync(string filePath)
{
try
{
var data = await dropboxClient.Files.GetMetadataAsync(filePath);
@ -171,11 +136,7 @@ namespace ASC.Files.Thirdparty.Dropbox
throw;
}
}
public List<Metadata> GetItems(string folderPath)
{
return new List<Metadata>(dropboxClient.Files.ListFolderAsync(folderPath).Result.Entries);
}
public async Task<List<Metadata>> GetItemsAsync(string folderPath)
{
@ -183,10 +144,15 @@ namespace ASC.Files.Thirdparty.Dropbox
return new List<Metadata>(data.Entries);
}
public async Task<Stream> DownloadStreamAsync(string filePath, int offset = 0)
public Task<Stream> DownloadStreamAsync(string filePath, int offset = 0)
{
if (string.IsNullOrEmpty(filePath)) throw new ArgumentNullException("file");
return InternalDownloadStreamAsync(filePath, offset);
}
public async Task<Stream> InternalDownloadStreamAsync(string filePath, int offset = 0)
{
using var response = await dropboxClient.Files.DownloadAsync(filePath);
var tempBuffer = TempStream.Create();
using (var str = await response.GetContentAsStreamAsync())
@ -212,23 +178,11 @@ namespace ASC.Files.Thirdparty.Dropbox
{
var path = MakeDropboxPath(parentPath, title);
return dropboxClient.Files.UploadAsync(path, WriteMode.Add.Instance, true, body: fileStream);
}
public void DeleteItem(Metadata dropboxItem)
{
dropboxClient.Files.DeleteV2Async(dropboxItem.PathDisplay).Wait();
}
public Task DeleteItemAsync(Metadata dropboxItem)
{
return dropboxClient.Files.DeleteV2Async(dropboxItem.PathDisplay);
}
public FolderMetadata MoveFolder(string dropboxFolderPath, string dropboxFolderPathTo, string folderName)
{
var pathTo = MakeDropboxPath(dropboxFolderPathTo, folderName);
var result = dropboxClient.Files.MoveV2Async(dropboxFolderPath, pathTo, autorename: true).Result;
return (FolderMetadata)result.Metadata;
}
public async Task<FolderMetadata> MoveFolderAsync(string dropboxFolderPath, string dropboxFolderPathTo, string folderName)
@ -236,13 +190,6 @@ namespace ASC.Files.Thirdparty.Dropbox
var pathTo = MakeDropboxPath(dropboxFolderPathTo, folderName);
var result = await dropboxClient.Files.MoveV2Async(dropboxFolderPath, pathTo, autorename: true);
return (FolderMetadata)result.Metadata;
}
public FileMetadata MoveFile(string dropboxFilePath, string dropboxFolderPathTo, string fileName)
{
var pathTo = MakeDropboxPath(dropboxFolderPathTo, fileName);
var result = dropboxClient.Files.MoveV2Async(dropboxFilePath, pathTo, autorename: true).Result;
return (FileMetadata)result.Metadata;
}
public async Task<FileMetadata> MoveFileAsync(string dropboxFilePath, string dropboxFolderPathTo, string fileName)
@ -250,13 +197,6 @@ namespace ASC.Files.Thirdparty.Dropbox
var pathTo = MakeDropboxPath(dropboxFolderPathTo, fileName);
var result = await dropboxClient.Files.MoveV2Async(dropboxFilePath, pathTo, autorename: true);
return (FileMetadata)result.Metadata;
}
public FolderMetadata CopyFolder(string dropboxFolderPath, string dropboxFolderPathTo, string folderName)
{
var pathTo = MakeDropboxPath(dropboxFolderPathTo, folderName);
var result = dropboxClient.Files.CopyV2Async(dropboxFolderPath, pathTo, autorename: true).Result;
return (FolderMetadata)result.Metadata;
}
public async Task<FolderMetadata> CopyFolderAsync(string dropboxFolderPath, string dropboxFolderPathTo, string folderName)
@ -264,13 +204,6 @@ namespace ASC.Files.Thirdparty.Dropbox
var pathTo = MakeDropboxPath(dropboxFolderPathTo, folderName);
var result = await dropboxClient.Files.CopyV2Async(dropboxFolderPath, pathTo, autorename: true);
return (FolderMetadata)result.Metadata;
}
public FileMetadata CopyFile(string dropboxFilePath, string dropboxFolderPathTo, string fileName)
{
var pathTo = MakeDropboxPath(dropboxFolderPathTo, fileName);
var result = dropboxClient.Files.CopyV2Async(dropboxFilePath, pathTo, autorename: true).Result;
return (FileMetadata)result.Metadata;
}
public async Task<FileMetadata> CopyFileAsync(string dropboxFilePath, string dropboxFolderPathTo, string fileName)
@ -278,58 +211,29 @@ namespace ASC.Files.Thirdparty.Dropbox
var pathTo = MakeDropboxPath(dropboxFolderPathTo, fileName);
var result = await dropboxClient.Files.CopyV2Async(dropboxFilePath, pathTo, autorename: true);
return (FileMetadata)result.Metadata;
}
public FileMetadata SaveStream(string filePath, Stream fileStream)
{
return dropboxClient.Files.UploadAsync(filePath, WriteMode.Overwrite.Instance, body: fileStream).Result.AsFile;
}
public async Task<FileMetadata> SaveStreamAsync(string filePath, Stream fileStream)
{
var metadata = await dropboxClient.Files.UploadAsync(filePath, WriteMode.Overwrite.Instance, body: fileStream);
return metadata.AsFile;
}
public string CreateResumableSession()
{
return dropboxClient.Files.UploadSessionStartAsync(body: new MemoryStream()).Result.SessionId;
}
public async Task<string> CreateResumableSessionAsync()
{
var session = await dropboxClient.Files.UploadSessionStartAsync(body: new MemoryStream());
return session.SessionId;
}
public void Transfer(string dropboxSession, long offset, Stream stream)
{
dropboxClient.Files.UploadSessionAppendV2Async(new UploadSessionCursor(dropboxSession, (ulong)offset), body: stream).Wait();
}
public Task TransferAsync(string dropboxSession, long offset, Stream stream)
{
return dropboxClient.Files.UploadSessionAppendV2Async(new UploadSessionCursor(dropboxSession, (ulong)offset), body: stream);
}
public Metadata FinishResumableSession(string dropboxSession, string dropboxFolderPath, string fileName, long offset)
{
var dropboxFilePath = MakeDropboxPath(dropboxFolderPath, fileName);
return FinishResumableSession(dropboxSession, dropboxFilePath, offset);
}
public Task<Metadata> FinishResumableSessionAsync(string dropboxSession, string dropboxFolderPath, string fileName, long offset)
{
var dropboxFilePath = MakeDropboxPath(dropboxFolderPath, fileName);
return FinishResumableSessionAsync(dropboxSession, dropboxFilePath, offset);
}
public Metadata FinishResumableSession(string dropboxSession, string dropboxFilePath, long offset)
{
return dropboxClient.Files.UploadSessionFinishAsync(
new UploadSessionCursor(dropboxSession, (ulong)offset),
new CommitInfo(dropboxFilePath, WriteMode.Overwrite.Instance),
new MemoryStream()).Result;
}
public async Task<Metadata> FinishResumableSessionAsync(string dropboxSession, string dropboxFilePath, long offset)

17
products/ASC.Files/Core/Core/Thirdparty/GoogleDrive/GoogleDriveFileDao.cs vendored
View File

@ -288,11 +288,16 @@ namespace ASC.Files.Thirdparty.GoogleDrive
return Task.FromResult(false);
}
public async Task<File<string>> SaveFileAsync(File<string> file, Stream fileStream)
public Task<File<string>> SaveFileAsync(File<string> file, Stream fileStream)
{
if (file == null) throw new ArgumentNullException(nameof(file));
if (fileStream == null) throw new ArgumentNullException(nameof(fileStream));
return InternalSaveFileAsync(file, fileStream);
}
public async Task<File<string>> InternalSaveFileAsync(File<string> file, Stream fileStream)
{
DriveFile newDriveFile = null;
var storage = await ProviderInfo.StorageAsync;
@ -522,11 +527,17 @@ namespace ASC.Files.Thirdparty.GoogleDrive
return file;
}
public async Task<ChunkedUploadSession<string>> CreateUploadSessionAsync(File<string> file, long contentLength)
public Task<ChunkedUploadSession<string>> CreateUploadSessionAsync(File<string> file, long contentLength)
{
if (SetupInfo.ChunkUploadSize > contentLength)
return new ChunkedUploadSession<string>(RestoreIds(file), contentLength) { UseChunks = false };
return Task.FromResult(new ChunkedUploadSession<string>(RestoreIds(file), contentLength) { UseChunks = false });
return InternalCreateUploadSessionAsync(file, contentLength);
}
public async Task<ChunkedUploadSession<string>> InternalCreateUploadSessionAsync(File<string> file, long contentLength)
{
var uploadSession = new ChunkedUploadSession<string>(file, contentLength);
DriveFile driveFile;

7
products/ASC.Files/Core/Core/Thirdparty/GoogleDrive/GoogleDriveFolderDao.cs vendored
View File

@ -183,9 +183,14 @@ namespace ASC.Files.Thirdparty.GoogleDrive
return path;
}
public async Task<string> SaveFolderAsync(Folder<string> folder)
public Task<string> SaveFolderAsync(Folder<string> folder)
{
if (folder == null) throw new ArgumentNullException(nameof(folder));
return InternalSaveFolderAsync(folder);
}
public async Task<string> InternalSaveFolderAsync(Folder<string> folder)
{
if (folder.ID != null)
{
return await RenameFolderAsync(folder, folder.Title).ConfigureAwait(false);

16
products/ASC.Files/Core/Core/Thirdparty/GoogleDrive/GoogleDriveProviderInfo.cs vendored
View File

@ -196,10 +196,15 @@ namespace ASC.Files.Thirdparty.GoogleDrive
ServiceProvider = serviceProvider;
}
public async Task<GoogleDriveStorage> CreateStorageAsync(OAuth20Token token, int id)
public Task<GoogleDriveStorage> CreateStorageAsync(OAuth20Token token, int id)
{
if (Storage != null && Storage.IsOpened) return Storage;
if (Storage != null && Storage.IsOpened) return Task.FromResult(Storage);
return InternalCreateStorageAsync(token, id);
}
public async Task<GoogleDriveStorage> InternalCreateStorageAsync(OAuth20Token token, int id)
{
var driveStorage = ServiceProvider.GetService<GoogleDriveStorage>();
await CheckTokenAsync(token, id).ConfigureAwait(false);
@ -208,9 +213,14 @@ namespace ASC.Files.Thirdparty.GoogleDrive
return Storage = driveStorage;
}
private async Task CheckTokenAsync(OAuth20Token token, int id)
private Task CheckTokenAsync(OAuth20Token token, int id)
{
if (token == null) throw new UnauthorizedAccessException("Cannot create GoogleDrive session with given token");
return InternalCheckTokenAsync(token, id);
}
private async Task InternalCheckTokenAsync(OAuth20Token token, int id)
{
if (token.IsExpired)
{
token = OAuth20TokenHelper.RefreshToken<GoogleLoginProvider>(ConsumerFactory, token);

51
products/ASC.Files/Core/Utils/FileMarker.cs
View File

@ -311,11 +311,17 @@ namespace ASC.Web.Files.Utils
}
}
public async Task MarkAsNewAsync<T>(FileEntry<T> fileEntry, List<Guid> userIDs = null)
public Task MarkAsNewAsync<T>(FileEntry<T> fileEntry, List<Guid> userIDs = null)
{
if (CoreBaseSettings.Personal) return;
if (CoreBaseSettings.Personal) return Task.CompletedTask;
if (fileEntry == null) return;
if (fileEntry == null) return Task.CompletedTask;
return InternalMarkAsNewAsync(fileEntry, userIDs);
}
private async Task InternalMarkAsNewAsync<T>(FileEntry<T> fileEntry, List<Guid> userIDs = null)
{
userIDs ??= new List<Guid>();
var taskData = ServiceProvider.GetService<AsyncTaskData<T>>();
@ -338,16 +344,21 @@ namespace ASC.Web.Files.Utils
taskData.UserIDs = projectTeam;
}
ServiceProvider.GetService<FileMarkerHelper<T>>().Add(taskData);
}
ServiceProvider.GetService<FileMarkerHelper<T>>().Add(taskData);
}
public async Task RemoveMarkAsNewAsync<T>(FileEntry<T> fileEntry, Guid userID = default)
public Task RemoveMarkAsNewAsync<T>(FileEntry<T> fileEntry, Guid userID = default)
{
if (CoreBaseSettings.Personal) return;
if (CoreBaseSettings.Personal) return Task.CompletedTask;
userID = userID.Equals(default) ? AuthContext.CurrentAccount.ID : userID;
if (fileEntry == null) return;
if (fileEntry == null) return Task.CompletedTask;
return InternalRemoveMarkAsNewAsync(fileEntry, userID);
}
public async Task InternalRemoveMarkAsNewAsync<T>(FileEntry<T> fileEntry, Guid userID = default)
{
userID = userID.Equals(default) ? AuthContext.CurrentAccount.ID : userID;
var tagDao = DaoFactory.GetTagDao<T>();
var internalFolderDao = DaoFactory.GetFolderDao<int>();
@ -479,7 +490,7 @@ namespace ASC.Web.Files.Utils
removeTags.Add(parentTag);
}
}
}
}
}
public async Task RemoveMarkAsNewForAllAsync<T>(FileEntry<T> fileEntry)
@ -519,12 +530,18 @@ namespace ASC.Web.Files.Utils
return 0;
}
public async Task<List<FileEntry>> MarkedItemsAsync<T>(Folder<T> folder)
public Task<List<FileEntry>> MarkedItemsAsync<T>(Folder<T> folder)
{
if (folder == null) throw new ArgumentNullException(nameof(folder), FilesCommonResource.ErrorMassage_FolderNotFound);
if (!await FileSecurity.CanReadAsync(folder)) throw new SecurityException(FilesCommonResource.ErrorMassage_SecurityException_ViewFolder);
if (folder.RootFolderType == FolderType.TRASH && !Equals(folder.ID, await GlobalFolder.GetFolderTrashAsync<T>(DaoFactory))) throw new SecurityException(FilesCommonResource.ErrorMassage_ViewTrashItem);
return InternalMarkedItemsAsync(folder);
}
private async Task<List<FileEntry>> InternalMarkedItemsAsync<T>(Folder<T> folder)
{
if (!await FileSecurity.CanReadAsync(folder)) throw new SecurityException(FilesCommonResource.ErrorMassage_SecurityException_ViewFolder);
if (folder.RootFolderType == FolderType.TRASH && !Equals(folder.ID, await GlobalFolder.GetFolderTrashAsync<T>(DaoFactory))) throw new SecurityException(FilesCommonResource.ErrorMassage_ViewTrashItem);
var tagDao = DaoFactory.GetTagDao<T>();
var providerFolderDao = DaoFactory.GetFolderDao<string>();
var providerTagDao = DaoFactory.GetTagDao<string>();
@ -555,8 +572,8 @@ namespace ASC.Web.Files.Utils
.Distinct();
//TODO: refactoring
var entryTagsProvider = await GetEntryTagsAsync<string>(tags.Where(r=> r.EntryId is string));
var entryTagsInternal = await GetEntryTagsAsync<int>(tags.Where(r=> r.EntryId is int));
var entryTagsProvider = await GetEntryTagsAsync<string>(tags.Where(r => r.EntryId is string));
var entryTagsInternal = await GetEntryTagsAsync<int>(tags.Where(r => r.EntryId is int));
foreach (var entryTag in entryTagsInternal)
{
@ -615,7 +632,7 @@ namespace ASC.Web.Files.Utils
result.Add(entryTag.Key);
}
}
}
}
}
private async Task<Dictionary<FileEntry<T>, Tag>> GetEntryTagsAsync<T>(IAsyncEnumerable<Tag> tags)

7
products/ASC.People/Server/Controllers/PeopleController.cs
View File

@ -432,10 +432,15 @@ namespace ASC.Employee.Core.Controllers
[AllowAnonymous]
[Create(@"register")]
public async Task<string> RegisterUserOnPersonalAsync(RegisterPersonalUserModel model)
public Task<string> RegisterUserOnPersonalAsync(RegisterPersonalUserModel model)
{
if (!CoreBaseSettings.Personal) throw new MethodAccessException("Method is only available on personal.onlyoffice.com");
return InternalRegisterUserOnPersonalAsync(model);
}
private async Task<string> InternalRegisterUserOnPersonalAsync(RegisterPersonalUserModel model)
{
try
{
if (CoreBaseSettings.CustomMode) model.Lang = "ru-RU";

27
web/ASC.Web.Api/Controllers/SettingsController.cs
View File

@ -2158,29 +2158,34 @@ namespace ASC.Api.Settings
}
[Read("statistics/spaceusage/{id}")]
public async Task<List<UsageSpaceStatItemWrapper>> GetSpaceUsageStatistics(Guid id)
public Task<List<UsageSpaceStatItemWrapper>> GetSpaceUsageStatistics(Guid id)
{
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
var webtem = WebItemManagerSecurity.GetItems(WebZoneType.All, ItemAvailableState.All)
var webitem = WebItemManagerSecurity.GetItems(WebZoneType.All, ItemAvailableState.All)
.FirstOrDefault(item =>
item != null &&
item.ID == id &&
item.Context != null &&
item.Context.SpaceUsageStatManager != null);
if (webtem == null) return new List<UsageSpaceStatItemWrapper>();
if (webitem == null) return Task.FromResult(new List<UsageSpaceStatItemWrapper>());
var statData = await webtem.Context.SpaceUsageStatManager.GetStatDataAsync();
return InternalGetSpaceUsageStatistics(webitem);
}
private async Task<List<UsageSpaceStatItemWrapper>> InternalGetSpaceUsageStatistics(IWebItem webitem)
{
var statData = await webitem.Context.SpaceUsageStatManager.GetStatDataAsync();
return statData.ConvertAll(it => new UsageSpaceStatItemWrapper
{
Name = it.Name.HtmlEncode(),
Icon = it.ImgUrl,
Disabled = it.Disabled,
Size = FileSizeComment.FilesSizeToString(it.SpaceUsage),
Url = it.Url
});
{
Name = it.Name.HtmlEncode(),
Icon = it.ImgUrl,
Disabled = it.Disabled,
Size = FileSizeComment.FilesSizeToString(it.SpaceUsage),
Url = it.Url
});
}
[Read("statistics/visit")]

40
web/ASC.Web.Core/Files/DocumentService.cs
View File

@ -101,7 +101,7 @@ namespace ASC.Web.Core.Files
/// <exception>
/// </exception>
public static async Task<(int ResultPercent, string ConvertedDocumentUri)> GetConvertedUriAsync(
public static Task<(int ResultPercent, string ConvertedDocumentUri)> GetConvertedUriAsync(
FileUtility fileUtility,
string documentConverterUrl,
string documentUri,
@ -119,6 +119,23 @@ namespace ASC.Web.Core.Files
if (string.IsNullOrEmpty(fromExtension)) throw new ArgumentNullException(nameof(fromExtension), "Document's extension for conversion is not known");
if (string.IsNullOrEmpty(toExtension)) throw new ArgumentNullException(nameof(toExtension), "Extension for conversion is not known");
return InternalGetConvertedUriAsync(fileUtility, documentConverterUrl, documentUri, fromExtension, toExtension, documentRevisionId, password, thumbnail, spreadsheetLayout, isAsync, signatureSecret, clientFactory);
}
private static async Task<(int ResultPercent, string ConvertedDocumentUri)> InternalGetConvertedUriAsync(
FileUtility fileUtility,
string documentConverterUrl,
string documentUri,
string fromExtension,
string toExtension,
string documentRevisionId,
string password,
ThumbnailData thumbnail,
SpreadsheetLayout spreadsheetLayout,
bool isAsync,
string signatureSecret,
IHttpClientFactory clientFactory)
{
var title = Path.GetFileName(documentUri ?? "");
title = string.IsNullOrEmpty(title) || title.Contains('?') ? Guid.NewGuid().ToString() : title;
@ -303,7 +320,7 @@ namespace ASC.Web.Core.Files
}
}
public static async Task<(string DocBuilderKey, Dictionary<string, string> Urls)> DocbuilderRequestAsync(
public static Task<(string DocBuilderKey, Dictionary<string, string> Urls)> DocbuilderRequestAsync(
FileUtility fileUtility,
string docbuilderUrl,
string requestKey,
@ -318,6 +335,18 @@ namespace ASC.Web.Core.Files
if (string.IsNullOrEmpty(requestKey) && string.IsNullOrEmpty(scriptUrl))
throw new ArgumentException("requestKey or inputScript is empty");
return InternalDocbuilderRequestAsync(fileUtility, docbuilderUrl, requestKey, scriptUrl, isAsync, signatureSecret, clientFactory);
}
private static async Task<(string DocBuilderKey, Dictionary<string, string> Urls)> InternalDocbuilderRequestAsync(
FileUtility fileUtility,
string docbuilderUrl,
string requestKey,
string scriptUrl,
bool isAsync,
string signatureSecret,
IHttpClientFactory clientFactory)
{
var request = new HttpRequestMessage();
request.RequestUri = new Uri(docbuilderUrl);
request.Method = HttpMethod.Post;
@ -391,11 +420,16 @@ namespace ASC.Web.Core.Files
return (responseFromService.Value<string>("key"), urls);
}
public static async Task<bool> HealthcheckRequestAsync(string healthcheckUrl, IHttpClientFactory clientFactory)
public static Task<bool> HealthcheckRequestAsync(string healthcheckUrl, IHttpClientFactory clientFactory)
{
if (string.IsNullOrEmpty(healthcheckUrl))
throw new ArgumentNullException(nameof(healthcheckUrl));
return InternalHealthcheckRequestAsync(healthcheckUrl, clientFactory);
}
private static async Task<bool> InternalHealthcheckRequestAsync(string healthcheckUrl, IHttpClientFactory clientFactory)
{
var request = new HttpRequestMessage();
request.RequestUri = new Uri(healthcheckUrl);

13
web/ASC.Web.Core/Files/DocumentServiceLicense.cs
View File

@ -54,11 +54,16 @@ namespace ASC.Web.Core.Files
ClientFactory = clientFactory;
}
private async Task<CommandResponse> GetDocumentServiceLicenseAsync()
private Task<CommandResponse> GetDocumentServiceLicenseAsync()
{
if (!CoreBaseSettings.Standalone) return null;
if (string.IsNullOrEmpty(FilesLinkUtility.DocServiceCommandUrl)) return null;
if (!CoreBaseSettings.Standalone) return Task.FromResult<CommandResponse>(null);
if (string.IsNullOrEmpty(FilesLinkUtility.DocServiceCommandUrl)) return Task.FromResult<CommandResponse>(null);
return InternalGetDocumentServiceLicenseAsync();
}
private async Task<CommandResponse> InternalGetDocumentServiceLicenseAsync()
{
var cacheKey = "DocumentServiceLicense";
var commandResponse = Cache.Get<CommandResponse>(cacheKey);
if (commandResponse == null)
@ -77,7 +82,7 @@ namespace ASC.Web.Core.Files
Cache.Insert(cacheKey, commandResponse, DateTime.UtcNow.Add(CACHE_EXPIRATION));
}
return commandResponse;
return commandResponse;
}
public async Task<Dictionary<string, DateTime>> GetLicenseQuotaAsync()

16
web/ASC.Web.Core/Sms/SmsManager.cs
View File

@ -63,7 +63,7 @@ namespace ASC.Web.Studio.Core.SMS
StudioSmsNotificationSettingsHelper = studioSmsNotificationSettingsHelper;
}
public async Task<string> SaveMobilePhoneAsync(UserInfo user, string mobilePhone)
public Task<string> SaveMobilePhoneAsync(UserInfo user, string mobilePhone)
{
mobilePhone = SmsSender.GetPhoneValueDigits(mobilePhone);
@ -71,6 +71,11 @@ namespace ASC.Web.Studio.Core.SMS
if (string.IsNullOrEmpty(mobilePhone)) throw new Exception(Resource.ActivateMobilePhoneEmptyPhoneNumber);
if (!string.IsNullOrEmpty(user.MobilePhone) && user.MobilePhoneActivationStatus == MobilePhoneActivationStatus.Activated) throw new Exception(Resource.MobilePhoneMustErase);
return InternalSaveMobilePhoneAsync(user, mobilePhone);
}
private async Task<string> InternalSaveMobilePhoneAsync(UserInfo user, string mobilePhone)
{
user.MobilePhone = mobilePhone;
user.MobilePhoneActivationStatus = MobilePhoneActivationStatus.NotActivated;
if (SecurityContext.IsAuthenticated)
@ -98,7 +103,7 @@ namespace ASC.Web.Studio.Core.SMS
return mobilePhone;
}
public async Task PutAuthCodeAsync(UserInfo user, bool again)
public Task PutAuthCodeAsync(UserInfo user, bool again)
{
if (user == null || Equals(user, Constants.LostUser)) throw new Exception(Resource.ErrorUserNotFound);
@ -106,9 +111,14 @@ namespace ASC.Web.Studio.Core.SMS
var mobilePhone = SmsSender.GetPhoneValueDigits(user.MobilePhone);
if (SmsKeyStorage.ExistsKey(mobilePhone) && !again) return;
if (SmsKeyStorage.ExistsKey(mobilePhone) && !again) return Task.CompletedTask;
if (!SmsKeyStorage.GenerateKey(mobilePhone, out var key)) throw new Exception(Resource.SmsTooMuchError);
return InternalPutAuthCodeAsync(mobilePhone, key);
}
private async Task InternalPutAuthCodeAsync(string mobilePhone, string key)
{
if (await SmsSender.SendSMSAsync(mobilePhone, string.Format(Resource.SmsAuthenticationMessageToUser, key)))
{
TenantManager.SetTenantQuotaRow(new TenantQuotaRow { Tenant = TenantManager.GetCurrentTenant().TenantId, Path = "/sms", Counter = 1 }, true);