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

Files: optimization

Browse Source
This commit is contained in:
pavelbannov 2021-12-24 13:43:19 +03:00
parent c85bd19cf7
commit 7946cdfb21
51 changed files with 622 additions and 622 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -209,7 +209,7 @@ namespace ASC.Files.Core.Data
return result;
}
protected async Task<object> MappingIDAsync(object id, bool saveIfNotExist)
protected async ValueTask<object> MappingIDAsync(object id, bool saveIfNotExist = false)
{
if (id == null) return null;
@ -260,10 +260,6 @@ namespace ASC.Files.Core.Data
protected object MappingID(object id)
{
return MappingID(id, false);
}
protected async Task<object> MappingIDAsync(object id)
{
return await MappingIDAsync(id, false);
}
internal static IQueryable<T> BuildSearch<T>(IQueryable<T> query, string text, SearhTypeEnum searhTypeEnum) where T : IDbSearch

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

@ -179,11 +179,11 @@ namespace ASC.Files.Core.Data
return ToFile(await FromQueryWithShared(query).FirstOrDefaultAsync().ConfigureAwait(false));
}
public async Task<List<File<int>>> GetFileHistoryAsync(int fileId)
public Task<List<File<int>>> GetFileHistoryAsync(int fileId)
{
var query = GetFileQuery(r => r.Id == fileId).OrderByDescending(r => r.Version).AsNoTracking();
return await FromQueryWithShared(query).Select(e => ToFile(e)).ToListAsync().ConfigureAwait(false);
return FromQueryWithShared(query).Select(e => ToFile(e)).ToListAsync();
}
public IAsyncEnumerable<File<int>> GetFilesAsync(IEnumerable<int> fileIds)
@ -250,14 +250,14 @@ namespace ASC.Files.Core.Data
return (checkShared ? FromQueryWithShared(query) : FromQuery(query)).Select(e => ToFile(e)).AsAsyncEnumerable();
}
public async Task<List<int>> GetFilesAsync(int parentId)
public Task<List<int>> GetFilesAsync(int parentId)
{
return await Query(FilesDbContext.Files)
return Query(FilesDbContext.Files)
.AsNoTracking()
.Where(r => r.FolderId == parentId && r.CurrentVersion)
.Select(r => r.Id)
.ToListAsync()
.ConfigureAwait(false);
;
}
public IAsyncEnumerable<File<int>> GetFilesAsync(int parentId, OrderBy orderBy, FilterType filterType, bool subjectGroup, Guid subjectID, string searchText, bool searchInContent, bool withSubfolders = false)
@ -337,9 +337,9 @@ namespace ASC.Files.Core.Data
return FromQueryWithShared(q).AsAsyncEnumerable().Select(ToFile);
}
public async Task<Stream> GetFileStreamAsync(File<int> file, long offset)
public Task<Stream> GetFileStreamAsync(File<int> file, long offset)
{
return await GlobalStore.GetStore().GetReadStreamAsync(string.Empty, GetUniqFilePath(file), (int)offset).ConfigureAwait(false);
return GlobalStore.GetStore().GetReadStreamAsync(string.Empty, GetUniqFilePath(file), (int)offset);
}
public Task<Uri> GetPreSignedUriAsync(File<int> file, TimeSpan expires)
@ -356,14 +356,14 @@ namespace ASC.Files.Core.Data
return Task.FromResult(GlobalStore.GetStore().IsSupportedPreSignedUri);
}
public async Task<Stream> GetFileStreamAsync(File<int> file)
public Task<Stream> GetFileStreamAsync(File<int> file)
{
return await GlobalStore.GetStore().GetReadStreamAsync(string.Empty, GetUniqFilePath(file), 0).ConfigureAwait(false);
return GlobalStore.GetStore().GetReadStreamAsync(string.Empty, GetUniqFilePath(file), 0);
}
public async Task<File<int>> SaveFileAsync(File<int> file, Stream fileStream)
public Task<File<int>> SaveFileAsync(File<int> file, Stream fileStream)
{
return await SaveFileAsync(file, fileStream, true).ConfigureAwait(false);
return SaveFileAsync(file, fileStream, true);
}
public async Task<File<int>> SaveFileAsync(File<int> file, Stream fileStream, bool checkQuota = true)
@ -498,7 +498,7 @@ namespace ASC.Files.Core.Data
var stored = GlobalStore.GetStore().IsDirectory(GetUniqFileDirectory(file.ID));
await DeleteFileAsync(file.ID, stored).ConfigureAwait(false);
}
else if (!IsExistOnStorageAsync(file).Result)
else if (!await IsExistOnStorageAsync(file))
{
await DeleteVersionAsync(file).ConfigureAwait(false);
}
@ -660,9 +660,9 @@ namespace ASC.Files.Core.Data
GlobalStore.GetStore().Save(string.Empty, GetUniqFilePath(file), stream, file.Title);
}
public async Task DeleteFileAsync(int fileId)
public Task DeleteFileAsync(int fileId)
{
await DeleteFileAsync(fileId, true).ConfigureAwait(false);
return DeleteFileAsync(fileId, true);
}
private async Task DeleteFileAsync(int fileId, bool deleteFolder)
@ -714,21 +714,21 @@ namespace ASC.Files.Core.Data
}
}
public async Task<bool> IsExistAsync(string title, object folderId)
public Task<bool> IsExistAsync(string title, object folderId)
{
if (folderId is int fId) return await IsExistAsync(title, fId).ConfigureAwait(false);
if (folderId is int fId) return IsExistAsync(title, fId);
throw new NotImplementedException();
}
public async Task<bool> IsExistAsync(string title, int folderId)
public Task<bool> IsExistAsync(string title, int folderId)
{
return await Query(FilesDbContext.Files)
return Query(FilesDbContext.Files)
.AsNoTracking()
.AnyAsync(r => r.Title == title &&
r.FolderId == folderId &&
r.CurrentVersion)
.ConfigureAwait(false);
;
}
public async Task<TTo> MoveFileAsync<TTo>(int fileId, TTo toFolderId)
@ -916,7 +916,7 @@ namespace ASC.Files.Core.Data
return comment;
}
public async Task CompleteVersionAsync(int fileId, int fileVersion)
public Task CompleteVersionAsync(int fileId, int fileVersion)
{
var toUpdate = Query(FilesDbContext.Files)
.Where(r => r.Id == fileId)
@ -927,7 +927,7 @@ namespace ASC.Files.Core.Data
f.VersionGroup += 1;
}
await FilesDbContext.SaveChangesAsync().ConfigureAwait(false);
return FilesDbContext.SaveChangesAsync();
}
public async Task ContinueVersionAsync(int fileId, int fileVersion)
@ -989,9 +989,9 @@ namespace ASC.Files.Core.Data
: null;
}
private async Task RecalculateFilesCountAsync(int folderId)
private Task RecalculateFilesCountAsync(int folderId)
{
await GetRecalculateFilesCountUpdateAsync(folderId).ConfigureAwait(false);
return GetRecalculateFilesCountUpdateAsync(folderId);
}
#region chunking
@ -1069,7 +1069,7 @@ namespace ASC.Files.Core.Data
#region Only in TMFileDao
public async Task ReassignFilesAsync(int[] fileIds, Guid newOwnerId)
public Task ReassignFilesAsync(int[] fileIds, Guid newOwnerId)
{
var toUpdate = Query(FilesDbContext.Files)
.Where(r => r.CurrentVersion)
@ -1080,7 +1080,7 @@ namespace ASC.Files.Core.Data
f.CreateBy = newOwnerId;
}
await FilesDbContext.SaveChangesAsync().ConfigureAwait(false);
return FilesDbContext.SaveChangesAsync();
}
public async Task<List<File<int>>> GetFilesAsync(IEnumerable<int> parentIds, FilterType filterType, bool subjectGroup, Guid subjectID, string searchText, bool searchInContent)
@ -1171,9 +1171,9 @@ namespace ASC.Files.Core.Data
GlobalStore.GetStore().DeleteDirectory(GetUniqFileDirectory(fileId));
}
public async Task<bool> IsExistOnStorageAsync(File<int> file)
public Task<bool> IsExistOnStorageAsync(File<int> file)
{
return await GlobalStore.GetStore().IsFileAsync(string.Empty, GetUniqFilePath(file)).ConfigureAwait(false);
return GlobalStore.GetStore().IsFileAsync(string.Empty, GetUniqFilePath(file));
}
private const string DiffTitle = "diff.zip";
@ -1234,18 +1234,18 @@ namespace ASC.Files.Core.Data
.ToList();
}
public async Task<Stream> GetDifferenceStreamAsync(File<int> file)
public Task<Stream> GetDifferenceStreamAsync(File<int> file)
{
return await GlobalStore.GetStore().GetReadStreamAsync(string.Empty, GetUniqFilePath(file, DiffTitle), 0).ConfigureAwait(false);
return GlobalStore.GetStore().GetReadStreamAsync(string.Empty, GetUniqFilePath(file, DiffTitle), 0);
}
public async Task<bool> ContainChangesAsync(int fileId, int fileVersion)
public Task<bool> ContainChangesAsync(int fileId, int fileVersion)
{
return await Query(FilesDbContext.Files)
return Query(FilesDbContext.Files)
.AnyAsync(r => r.Id == fileId &&
r.Version == fileVersion &&
r.Changes != null)
.ConfigureAwait(false);
;
}
public async Task<IEnumerable<(File<int>, SmallShareRecord)>> GetFeedsAsync(int tenant, DateTime from, DateTime to)

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

@ -293,9 +293,9 @@ namespace ASC.Files.Core.Data
return query.ConvertAll(e => ToFolder(e));
}
public async Task<int> SaveFolderAsync(Folder<int> folder)
public Task<int> SaveFolderAsync(Folder<int> folder)
{
return await SaveFolderAsync(folder, null).ConfigureAwait(false);
return SaveFolderAsync(folder, null);
}
public async Task<int> SaveFolderAsync(Folder<int> folder, IDbContextTransaction transaction)
@ -404,10 +404,10 @@ namespace ASC.Files.Core.Data
return folder.ID;
}
private async Task<bool> IsExistAsync(int folderId)
private Task<bool> IsExistAsync(int folderId)
{
return await Query(FilesDbContext.Folders).AsNoTracking()
.AnyAsync(r => r.Id == folderId).ConfigureAwait(false);
return Query(FilesDbContext.Folders).AsNoTracking()
.AnyAsync(r => r.Id == folderId);
}
public async Task DeleteFolderAsync(int id)
@ -623,16 +623,16 @@ namespace ASC.Files.Core.Data
return moved;
}
public async Task<IDictionary<int, string>> CanMoveOrCopyAsync<TTo>(int[] folderIds, TTo to)
public Task<IDictionary<int, string>> CanMoveOrCopyAsync<TTo>(int[] folderIds, TTo to)
{
if (to is int tId)
{
return await CanMoveOrCopyAsync(folderIds, tId).ConfigureAwait(false);
return CanMoveOrCopyAsync(folderIds, tId);
}
if (to is string tsId)
{
return await CanMoveOrCopyAsync(folderIds, tsId).ConfigureAwait(false);
return CanMoveOrCopyAsync(folderIds, tsId);
}
throw new NotImplementedException();
@ -809,7 +809,7 @@ namespace ASC.Files.Core.Data
#region Only for TMFolderDao
public async Task ReassignFoldersAsync(int[] folderIds, Guid newOwnerId)
public Task ReassignFoldersAsync(int[] folderIds, Guid newOwnerId)
{
var toUpdate = Query(FilesDbContext.Folders)
.Where(r => folderIds.Contains(r.Id));
@ -819,7 +819,7 @@ namespace ASC.Files.Core.Data
f.CreateBy = newOwnerId;
}
await FilesDbContext.SaveChangesAsync().ConfigureAwait(false);
return FilesDbContext.SaveChangesAsync();
}
public async Task<IEnumerable<Folder<int>>> SearchFoldersAsync(string text, bool bunch)
@ -1018,49 +1018,49 @@ namespace ASC.Files.Core.Data
return newFolderId;
}
async Task<int> IFolderDao<int>.GetFolderIDProjectsAsync(bool createIfNotExists)
Task<int> IFolderDao<int>.GetFolderIDProjectsAsync(bool createIfNotExists)
{
return await (this as IFolderDao<int>).GetFolderIDAsync(FileConstant.ModuleId, projects, null, createIfNotExists).ConfigureAwait(false);
return (this as IFolderDao<int>).GetFolderIDAsync(FileConstant.ModuleId, projects, null, createIfNotExists);
}
public async Task<int> GetFolderIDTrashAsync(bool createIfNotExists, Guid? userId = null)
public Task<int> GetFolderIDTrashAsync(bool createIfNotExists, Guid? userId = null)
{
return await (this as IFolderDao<int>).GetFolderIDAsync(FileConstant.ModuleId, trash, (userId ?? AuthContext.CurrentAccount.ID).ToString(), createIfNotExists).ConfigureAwait(false);
return (this as IFolderDao<int>).GetFolderIDAsync(FileConstant.ModuleId, trash, (userId ?? AuthContext.CurrentAccount.ID).ToString(), createIfNotExists);
}
public async Task<int> GetFolderIDCommonAsync(bool createIfNotExists)
public Task<int> GetFolderIDCommonAsync(bool createIfNotExists)
{
return await (this as IFolderDao<int>).GetFolderIDAsync(FileConstant.ModuleId, common, null, createIfNotExists).ConfigureAwait(false);
return (this as IFolderDao<int>).GetFolderIDAsync(FileConstant.ModuleId, common, null, createIfNotExists);
}
public async Task<int> GetFolderIDUserAsync(bool createIfNotExists, Guid? userId = null)
public Task<int> GetFolderIDUserAsync(bool createIfNotExists, Guid? userId = null)
{
return await (this as IFolderDao<int>).GetFolderIDAsync(FileConstant.ModuleId, my, (userId ?? AuthContext.CurrentAccount.ID).ToString(), createIfNotExists).ConfigureAwait(false);
return (this as IFolderDao<int>).GetFolderIDAsync(FileConstant.ModuleId, my, (userId ?? AuthContext.CurrentAccount.ID).ToString(), createIfNotExists);
}
public async Task<int> GetFolderIDShareAsync(bool createIfNotExists)
public Task<int> GetFolderIDShareAsync(bool createIfNotExists)
{
return await (this as IFolderDao<int>).GetFolderIDAsync(FileConstant.ModuleId, share, null, createIfNotExists).ConfigureAwait(false);
return (this as IFolderDao<int>).GetFolderIDAsync(FileConstant.ModuleId, share, null, createIfNotExists);
}
public async Task<int> GetFolderIDRecentAsync(bool createIfNotExists)
public Task<int> GetFolderIDRecentAsync(bool createIfNotExists)
{
return await (this as IFolderDao<int>).GetFolderIDAsync(FileConstant.ModuleId, recent, null, createIfNotExists).ConfigureAwait(false);
return (this as IFolderDao<int>).GetFolderIDAsync(FileConstant.ModuleId, recent, null, createIfNotExists);
}
public async Task<int> GetFolderIDFavoritesAsync(bool createIfNotExists)
public Task<int> GetFolderIDFavoritesAsync(bool createIfNotExists)
{
return await (this as IFolderDao<int>).GetFolderIDAsync(FileConstant.ModuleId, favorites, null, createIfNotExists).ConfigureAwait(false);
return (this as IFolderDao<int>).GetFolderIDAsync(FileConstant.ModuleId, favorites, null, createIfNotExists);
}
public async Task<int> GetFolderIDTemplatesAsync(bool createIfNotExists)
public Task<int> GetFolderIDTemplatesAsync(bool createIfNotExists)
{
return await (this as IFolderDao<int>).GetFolderIDAsync(FileConstant.ModuleId, templates, null, createIfNotExists).ConfigureAwait(false);
return (this as IFolderDao<int>).GetFolderIDAsync(FileConstant.ModuleId, templates, null, createIfNotExists);
}
public async Task<int> GetFolderIDPrivacyAsync(bool createIfNotExists, Guid? userId = null)
public Task<int> GetFolderIDPrivacyAsync(bool createIfNotExists, Guid? userId = null)
{
return await (this as IFolderDao<int>).GetFolderIDAsync(FileConstant.ModuleId, privacy, (userId ?? AuthContext.CurrentAccount.ID).ToString(), createIfNotExists).ConfigureAwait(false);
return (this as IFolderDao<int>).GetFolderIDAsync(FileConstant.ModuleId, privacy, (userId ?? AuthContext.CurrentAccount.ID).ToString(), createIfNotExists);
}
@ -1200,23 +1200,23 @@ namespace ASC.Files.Core.Data
return (file, record);
}
public async Task<string> GetBunchObjectIDAsync(int folderID)
public Task<string> GetBunchObjectIDAsync(int folderID)
{
return await Query(FilesDbContext.BunchObjects)
return Query(FilesDbContext.BunchObjects)
.Where(r => r.LeftNode == (folderID).ToString())
.Select(r => r.RightNode)
.FirstOrDefaultAsync()
.ConfigureAwait(false);
;
}
public async Task<Dictionary<string, string>> GetBunchObjectIDsAsync(List<int> folderIDs)
public Task<Dictionary<string, string>> GetBunchObjectIDsAsync(List<int> folderIDs)
{
var folderSIds = folderIDs.Select(r => r.ToString()).ToList();
return await Query(FilesDbContext.BunchObjects)
return Query(FilesDbContext.BunchObjects)
.Where(r => folderSIds.Any(a => a == r.LeftNode))
.ToDictionaryAsync(r => r.LeftNode, r => r.RightNode)
.ConfigureAwait(false);
;
}
public async Task<IEnumerable<(Folder<int>, SmallShareRecord)>> GetFeedsForFoldersAsync(int tenant, DateTime from, DateTime to)

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

@ -884,7 +884,7 @@ ctx.Tag
}
}
private async Task<Tag> ToTagAsync(TagLinkData r)
private async ValueTask<Tag> ToTagAsync(TagLinkData r)
{
var result = new Tag(r.Tag.Name, r.Tag.Flag, r.Tag.Owner, r.Link.TagCount)
{

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

@ -1293,7 +1293,7 @@ namespace ASC.Web.Files.Services.WCFService
&& !Equals(file.RootFolderCreator, AuthContext.CurrentAccount.ID))
{
var folderDao = GetFolderDao();
if (!FileSecurity.CanRead(folderDao.GetFolderAsync(file.FolderID).Result))
if (!FileSecurity.CanRead(await folderDao.GetFolderAsync(file.FolderID)))
{
file.FolderIdDisplay = GlobalFolderHelper.GetFolderShare<T>();
}
@ -2003,7 +2003,7 @@ namespace ASC.Web.Files.Services.WCFService
}
var provider = await providerDao.GetProviderInfoAsync(curProviderId);
provider.InvalidateStorageAsync().Wait();
await provider.InvalidateStorageAsync();
var folderDao1 = GetFolderDao();
var folder = await folderDao1.GetFolderAsync((T)Convert.ChangeType(provider.RootFolderId, typeof(T)));
@ -2304,7 +2304,7 @@ namespace ASC.Web.Files.Services.WCFService
}
try
{
foreach (var pair in folderDao.CanMoveOrCopyAsync(foldersId.ToArray(), toFolder.ID).Result)
foreach (var pair in await folderDao.CanMoveOrCopyAsync(foldersId.ToArray(), toFolder.ID))
{
checkedFolders.Add(pair.Key);
}
@ -2820,9 +2820,9 @@ namespace ASC.Web.Files.Services.WCFService
return FileSharing.GetSharedInfo(fileIds, folderIds);
}
public async Task<List<AceWrapper>> GetSharedInfoAsync(IEnumerable<T> fileIds, IEnumerable<T> folderIds)
public Task<List<AceWrapper>> GetSharedInfoAsync(IEnumerable<T> fileIds, IEnumerable<T> folderIds)
{
return await FileSharing.GetSharedInfoAsync(fileIds, folderIds);
return FileSharing.GetSharedInfoAsync(fileIds, folderIds);
}
public List<AceShortWrapper> GetSharedInfoShortFile(T fileId)
@ -2920,7 +2920,7 @@ namespace ASC.Web.Files.Services.WCFService
FileSharingAceHelper.RemoveAce(entries);
}
public async Task RemoveAceAsync(List<T> filesId, List<T> foldersId)
public Task RemoveAceAsync(List<T> filesId, List<T> foldersId)
{
ErrorIf(!AuthContext.IsAuthenticated, FilesCommonResource.ErrorMassage_SecurityException);
var entries = AsyncEnumerable.Empty<FileEntry<T>>();
@ -2931,7 +2931,7 @@ namespace ASC.Web.Files.Services.WCFService
entries.Concat(foldersId.ToAsyncEnumerable().SelectAwait(async e => await folderDao.GetFolderAsync(e)));
await FileSharingAceHelper.RemoveAceAsync(entries);
return FileSharingAceHelper.RemoveAceAsync(entries);
}
public string GetShortenLink(T fileId)

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

@ -204,9 +204,9 @@ namespace ASC.Files.Core.Security
return WhoCan(entry, FilesSecurityActions.Read);
}
public async Task<IEnumerable<Guid>> WhoCanReadAsync<T>(FileEntry<T> entry)
public Task<IEnumerable<Guid>> WhoCanReadAsync<T>(FileEntry<T> entry)
{
return await WhoCanAsync(entry, FilesSecurityActions.Read);
return WhoCanAsync(entry, FilesSecurityActions.Read);
}
private IEnumerable<Guid> WhoCan<T>(FileEntry<T> entry, FilesSecurityActions action)
@ -408,7 +408,7 @@ namespace ASC.Files.Core.Security
var root = await folderDao.GetFolderAsync(entry.RootFolderId);
if (root != null)
{
var path = folderDao.GetBunchObjectIDAsync(root.ID).Result;
var path = await folderDao.GetBunchObjectIDAsync(root.ID);
var adapter = FilesIntegration.GetFileSecurity(path);

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

@ -44,7 +44,6 @@ using ASC.Web.Studio.Core;
using Box.V2.Models;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Options;
namespace ASC.Files.Thirdparty.Box
@ -85,9 +84,9 @@ namespace ASC.Files.Thirdparty.Box
if (parentPath != null) await ProviderInfo.CacheResetAsync(parentPath).ConfigureAwait(false);
}
public async Task<File<string>> GetFileAsync(string fileId)
public Task<File<string>> GetFileAsync(string fileId)
{
return await GetFileAsync(fileId, 1).ConfigureAwait(false);
return GetFileAsync(fileId, 1);
}
public async Task<File<string>> GetFileAsync(string fileId, int fileVersion)
@ -248,9 +247,9 @@ namespace ASC.Files.Thirdparty.Box
}
}
public override async Task<Stream> GetFileStreamAsync(File<string> file)
public override Task<Stream> GetFileStreamAsync(File<string> file)
{
return await GetFileStreamAsync(file, 0).ConfigureAwait(false);
return GetFileStreamAsync(file, 0);
}
public async Task<Stream> GetFileStreamAsync(File<string> file, long offset)
@ -310,9 +309,9 @@ namespace ASC.Files.Thirdparty.Box
return ToFile(newBoxFile);
}
public async Task<File<string>> ReplaceFileVersionAsync(File<string> file, Stream fileStream)
public Task<File<string>> ReplaceFileVersionAsync(File<string> file, Stream fileStream)
{
return await SaveFileAsync(file, fileStream).ConfigureAwait(false);
return SaveFileAsync(file, fileStream);
}
public async Task DeleteFileAsync(string fileId)

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

@ -91,9 +91,9 @@ namespace ASC.Files.Thirdparty.Box
return ToFolder(items.FirstOrDefault(item => item.Name.Equals(title, StringComparison.InvariantCultureIgnoreCase)) as BoxFolder);
}
public async Task<Folder<string>> GetRootFolderByFileAsync(string fileId)
public Task<Folder<string>> GetRootFolderByFileAsync(string fileId)
{
return await GetRootFolderAsync(fileId).ConfigureAwait(false);
return GetRootFolderAsync(fileId);
}
public async IAsyncEnumerable<Folder<string>> GetFoldersAsync(string parentId)
@ -359,16 +359,16 @@ namespace ASC.Files.Thirdparty.Box
return moved;
}
public async Task<IDictionary<string, string>> CanMoveOrCopyAsync<TTo>(string[] folderIds, TTo to)
public Task<IDictionary<string, string>> CanMoveOrCopyAsync<TTo>(string[] folderIds, TTo to)
{
if (to is int tId)
{
return await CanMoveOrCopyAsync(folderIds, tId).ConfigureAwait(false);
return CanMoveOrCopyAsync(folderIds, tId);
}
if (to is string tsId)
{
return await CanMoveOrCopyAsync(folderIds, tsId).ConfigureAwait(false);
return CanMoveOrCopyAsync(folderIds, tsId);
}
throw new NotImplementedException();

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

@ -127,14 +127,14 @@ namespace ASC.Files.Thirdparty.Box
}
}
public async Task InvalidateStorageAsync()
public Task InvalidateStorageAsync()
{
if (Wrapper != null)
{
Wrapper.Dispose();
}
await CacheResetAsync().ConfigureAwait(false);
return CacheResetAsync();
}
public void UpdateTitle(string newtitle)
@ -142,29 +142,29 @@ namespace ASC.Files.Thirdparty.Box
CustomerTitle = newtitle;
}
internal async Task<BoxFolder> GetBoxFolderAsync(string dropboxFolderPath)
internal Task<BoxFolder> GetBoxFolderAsync(string dropboxFolderPath)
{
return await BoxProviderInfoHelper.GetBoxFolderAsync(Storage, ID, dropboxFolderPath).ConfigureAwait(false);
return BoxProviderInfoHelper.GetBoxFolderAsync(Storage, ID, dropboxFolderPath);
}
internal async Task<BoxFile> GetBoxFileAsync(string dropboxFilePath)
internal Task<BoxFile> GetBoxFileAsync(string dropboxFilePath)
{
return await BoxProviderInfoHelper.GetBoxFileAsync(Storage, ID, dropboxFilePath).ConfigureAwait(false);
return BoxProviderInfoHelper.GetBoxFileAsync(Storage, ID, dropboxFilePath);
}
internal async Task<List<BoxItem>> GetBoxItemsAsync(string dropboxFolderPath)
internal Task<List<BoxItem>> GetBoxItemsAsync(string dropboxFolderPath)
{
return await BoxProviderInfoHelper.GetBoxItemsAsync(Storage, ID, dropboxFolderPath).ConfigureAwait(false);
return BoxProviderInfoHelper.GetBoxItemsAsync(Storage, ID, dropboxFolderPath);
}
internal async Task CacheResetAsync(BoxItem boxItem)
internal Task CacheResetAsync(BoxItem boxItem)
{
await BoxProviderInfoHelper.CacheResetAsync(ID, boxItem).ConfigureAwait(false);
return BoxProviderInfoHelper.CacheResetAsync(ID, boxItem);
}
internal async Task CacheResetAsync(string boxPath = null, bool? isFile = null)
internal Task CacheResetAsync(string boxPath = null, bool? isFile = null)
{
await BoxProviderInfoHelper.CacheResetAsync(BoxRootId, ID, boxPath, isFile).ConfigureAwait(false);
return BoxProviderInfoHelper.CacheResetAsync(BoxRootId, ID, boxPath, isFile);
}
}

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

@ -238,7 +238,7 @@ namespace ASC.Files.Thirdparty.Box
return _boxClient.FoldersManager.CreateAsync(boxFolderRequest, _boxFields).Result;
}
public async Task<BoxFolder> CreateFolderAsync(string title, string parentId)
public Task<BoxFolder> CreateFolderAsync(string title, string parentId)
{
var boxFolderRequest = new BoxFolderRequest
{
@ -248,7 +248,7 @@ namespace ASC.Files.Thirdparty.Box
Id = parentId
}
};
return await _boxClient.FoldersManager.CreateAsync(boxFolderRequest, _boxFields);
return _boxClient.FoldersManager.CreateAsync(boxFolderRequest, _boxFields);
}
public BoxFile CreateFile(Stream fileStream, string title, string parentId)
@ -264,7 +264,7 @@ namespace ASC.Files.Thirdparty.Box
return _boxClient.FilesManager.UploadAsync(boxFileRequest, fileStream, _boxFields, setStreamPositionToZero: false).Result;
}
public async Task<BoxFile> CreateFileAsync(Stream fileStream, string title, string parentId)
public Task<BoxFile> CreateFileAsync(Stream fileStream, string title, string parentId)
{
var boxFileRequest = new BoxFileRequest
{
@ -274,7 +274,7 @@ namespace ASC.Files.Thirdparty.Box
Id = parentId
}
};
return await _boxClient.FilesManager.UploadAsync(boxFileRequest, fileStream, _boxFields, setStreamPositionToZero: false);
return _boxClient.FilesManager.UploadAsync(boxFileRequest, fileStream, _boxFields, setStreamPositionToZero: false);
}
public void DeleteItem(BoxItem boxItem)
@ -315,7 +315,7 @@ namespace ASC.Files.Thirdparty.Box
return _boxClient.FoldersManager.UpdateInformationAsync(boxFolderRequest, _boxFields).Result;
}
public async Task<BoxFolder> MoveFolderAsync(string boxFolderId, string newFolderName, string toFolderId)
public Task<BoxFolder> MoveFolderAsync(string boxFolderId, string newFolderName, string toFolderId)
{
var boxFolderRequest = new BoxFolderRequest
{
@ -326,7 +326,7 @@ namespace ASC.Files.Thirdparty.Box
Id = toFolderId
}
};
return await _boxClient.FoldersManager.UpdateInformationAsync(boxFolderRequest, _boxFields);
return _boxClient.FoldersManager.UpdateInformationAsync(boxFolderRequest, _boxFields);
}
public BoxFile MoveFile(string boxFileId, string newFileName, string toFolderId)
@ -343,7 +343,7 @@ namespace ASC.Files.Thirdparty.Box
return _boxClient.FilesManager.UpdateInformationAsync(boxFileRequest, null, _boxFields).Result;
}
public async Task<BoxFile> MoveFileAsync(string boxFileId, string newFileName, string toFolderId)
public Task<BoxFile> MoveFileAsync(string boxFileId, string newFileName, string toFolderId)
{
var boxFileRequest = new BoxFileRequest
{
@ -354,7 +354,7 @@ namespace ASC.Files.Thirdparty.Box
Id = toFolderId
}
};
return await _boxClient.FilesManager.UpdateInformationAsync(boxFileRequest, null, _boxFields);
return _boxClient.FilesManager.UpdateInformationAsync(boxFileRequest, null, _boxFields);
}
public BoxFolder CopyFolder(string boxFolderId, string newFolderName, string toFolderId)
@ -371,7 +371,7 @@ namespace ASC.Files.Thirdparty.Box
return _boxClient.FoldersManager.CopyAsync(boxFolderRequest, _boxFields).Result;
}
public async Task<BoxFolder> CopyFolderAsync(string boxFolderId, string newFolderName, string toFolderId)
public Task<BoxFolder> CopyFolderAsync(string boxFolderId, string newFolderName, string toFolderId)
{
var boxFolderRequest = new BoxFolderRequest
{
@ -382,7 +382,7 @@ namespace ASC.Files.Thirdparty.Box
Id = toFolderId
}
};
return await _boxClient.FoldersManager.CopyAsync(boxFolderRequest, _boxFields);
return _boxClient.FoldersManager.CopyAsync(boxFolderRequest, _boxFields);
}
public BoxFile CopyFile(string boxFileId, string newFileName, string toFolderId)
@ -399,7 +399,7 @@ namespace ASC.Files.Thirdparty.Box
return _boxClient.FilesManager.CopyAsync(boxFileRequest, _boxFields).Result;
}
public async Task<BoxFile> CopyFileAsync(string boxFileId, string newFileName, string toFolderId)
public Task<BoxFile> CopyFileAsync(string boxFileId, string newFileName, string toFolderId)
{
var boxFileRequest = new BoxFileRequest
{
@ -410,7 +410,7 @@ namespace ASC.Files.Thirdparty.Box
Id = toFolderId
}
};
return await _boxClient.FilesManager.CopyAsync(boxFileRequest, _boxFields);
return _boxClient.FilesManager.CopyAsync(boxFileRequest, _boxFields);
}
public BoxFolder RenameFolder(string boxFolderId, string newName)
@ -419,10 +419,10 @@ namespace ASC.Files.Thirdparty.Box
return _boxClient.FoldersManager.UpdateInformationAsync(boxFolderRequest, _boxFields).Result;
}
public async Task<BoxFolder> RenameFolderAsync(string boxFolderId, string newName)
public Task<BoxFolder> RenameFolderAsync(string boxFolderId, string newName)
{
var boxFolderRequest = new BoxFolderRequest { Id = boxFolderId, Name = newName };
return await _boxClient.FoldersManager.UpdateInformationAsync(boxFolderRequest, _boxFields);
return _boxClient.FoldersManager.UpdateInformationAsync(boxFolderRequest, _boxFields);
}
public BoxFile RenameFile(string boxFileId, string newName)
@ -431,10 +431,10 @@ namespace ASC.Files.Thirdparty.Box
return _boxClient.FilesManager.UpdateInformationAsync(boxFileRequest, null, _boxFields).Result;
}
public async Task<BoxFile> RenameFileAsync(string boxFileId, string newName)
public Task<BoxFile> RenameFileAsync(string boxFileId, string newName)
{
var boxFileRequest = new BoxFileRequest { Id = boxFileId, Name = newName };
return await _boxClient.FilesManager.UpdateInformationAsync(boxFileRequest, null, _boxFields);
return _boxClient.FilesManager.UpdateInformationAsync(boxFileRequest, null, _boxFields);
}
public BoxFile SaveStream(string fileId, Stream fileStream)
@ -442,9 +442,9 @@ namespace ASC.Files.Thirdparty.Box
return _boxClient.FilesManager.UploadNewVersionAsync(null, fileId, fileStream, fields: _boxFields, setStreamPositionToZero: false).Result;
}
public async Task<BoxFile> SaveStreamAsync(string fileId, Stream fileStream)
public Task<BoxFile> SaveStreamAsync(string fileId, Stream fileStream)
{
return await _boxClient.FilesManager.UploadNewVersionAsync(null, fileId, fileStream, fields: _boxFields, setStreamPositionToZero: false);
return _boxClient.FilesManager.UploadNewVersionAsync(null, fileId, fileStream, fields: _boxFields, setStreamPositionToZero: false);
}
public long GetMaxUploadSize()

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

@ -86,9 +86,9 @@ namespace ASC.Files.Thirdparty.Dropbox
if (parentPath != null) await ProviderInfo.CacheResetAsync(parentPath).ConfigureAwait(false);
}
public async Task<File<string>> GetFileAsync(string fileId)
public Task<File<string>> GetFileAsync(string fileId)
{
return await GetFileAsync(fileId, 1).ConfigureAwait(false);
return GetFileAsync(fileId, 1);
}
public async Task<File<string>> GetFileAsync(string fileId, int fileVersion)
@ -250,9 +250,9 @@ namespace ASC.Files.Thirdparty.Dropbox
}
}
public override async Task<Stream> GetFileStreamAsync(File<string> file)
public override Task<Stream> GetFileStreamAsync(File<string> file)
{
return await GetFileStreamAsync(file, 0).ConfigureAwait(false);
return GetFileStreamAsync(file, 0);
}
public async Task<Stream> GetFileStreamAsync(File<string> file, long offset)
@ -311,9 +311,9 @@ namespace ASC.Files.Thirdparty.Dropbox
return ToFile(newDropboxFile);
}
public async Task<File<string>> ReplaceFileVersionAsync(File<string> file, Stream fileStream)
public Task<File<string>> ReplaceFileVersionAsync(File<string> file, Stream fileStream)
{
return await SaveFileAsync(file, fileStream).ConfigureAwait(false);
return SaveFileAsync(file, fileStream);
}
public async Task DeleteFileAsync(string fileId)

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

@ -92,9 +92,9 @@ namespace ASC.Files.Thirdparty.Dropbox
: ToFolder(metadata.AsFolder);
}
public async Task<Folder<string>> GetRootFolderByFileAsync(string fileId)
public Task<Folder<string>> GetRootFolderByFileAsync(string fileId)
{
return await GetRootFolderAsync(fileId).ConfigureAwait(false);
return GetRootFolderAsync(fileId);
}
public async IAsyncEnumerable<Folder<string>> GetFoldersAsync(string parentId)
@ -354,16 +354,16 @@ namespace ASC.Files.Thirdparty.Dropbox
return ToFolder(newDropboxFolder);
}
public async Task<IDictionary<string, string>> CanMoveOrCopyAsync<TTo>(string[] folderIds, TTo to)
public Task<IDictionary<string, string>> CanMoveOrCopyAsync<TTo>(string[] folderIds, TTo to)
{
if (to is int tId)
{
return await CanMoveOrCopyAsync(folderIds, tId).ConfigureAwait(false);
return CanMoveOrCopyAsync(folderIds, tId);
}
if (to is string tsId)
{
return await CanMoveOrCopyAsync(folderIds, tsId).ConfigureAwait(false);
return CanMoveOrCopyAsync(folderIds, tsId);
}
throw new NotImplementedException();

24
products/ASC.Files/Core/Core/Thirdparty/Dropbox/DropboxProviderInfo.cs vendored
View File

@ -110,14 +110,14 @@ namespace ASC.Files.Thirdparty.Dropbox
return true;
}
public async Task InvalidateStorageAsync()
public Task InvalidateStorageAsync()
{
if (Wrapper != null)
{
Wrapper.Dispose();
}
await CacheResetAsync().ConfigureAwait(false);
return CacheResetAsync();
}
public void UpdateTitle(string newtitle)
@ -125,28 +125,28 @@ namespace ASC.Files.Thirdparty.Dropbox
CustomerTitle = newtitle;
}
internal async Task<FolderMetadata> GetDropboxFolderAsync(string dropboxFolderPath)
internal Task<FolderMetadata> GetDropboxFolderAsync(string dropboxFolderPath)
{
return await DropboxProviderInfoHelper.GetDropboxFolderAsync(Storage, ID, dropboxFolderPath).ConfigureAwait(false);
return DropboxProviderInfoHelper.GetDropboxFolderAsync(Storage, ID, dropboxFolderPath);
}
internal async Task<FileMetadata> GetDropboxFileAsync(string dropboxFilePath)
internal Task<FileMetadata> GetDropboxFileAsync(string dropboxFilePath)
{
return await DropboxProviderInfoHelper.GetDropboxFileAsync(Storage, ID, dropboxFilePath).ConfigureAwait(false);
return DropboxProviderInfoHelper.GetDropboxFileAsync(Storage, ID, dropboxFilePath);
}
internal async Task<List<Metadata>> GetDropboxItemsAsync(string dropboxFolderPath)
internal Task<List<Metadata>> GetDropboxItemsAsync(string dropboxFolderPath)
{
return await DropboxProviderInfoHelper.GetDropboxItemsAsync(Storage, ID, dropboxFolderPath).ConfigureAwait(false);
return DropboxProviderInfoHelper.GetDropboxItemsAsync(Storage, ID, dropboxFolderPath);
}
internal async Task CacheResetAsync(Metadata dropboxItem)
internal Task CacheResetAsync(Metadata dropboxItem)
{
await DropboxProviderInfoHelper.CacheResetAsync(ID, dropboxItem).ConfigureAwait(false);
return DropboxProviderInfoHelper.CacheResetAsync(ID, dropboxItem);
}
internal async Task CacheResetAsync(string dropboxPath = null, bool? isFile = null)
internal Task CacheResetAsync(string dropboxPath = null, bool? isFile = null)
{
await DropboxProviderInfoHelper.CacheResetAsync(ID, dropboxPath, isFile).ConfigureAwait(false);
return DropboxProviderInfoHelper.CacheResetAsync(ID, dropboxPath, isFile);
}
}

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

@ -225,10 +225,10 @@ namespace ASC.Files.Thirdparty.Dropbox
return dropboxClient.Files.UploadAsync(path, WriteMode.Add.Instance, true, body: fileStream).Result;
}
public async Task<FileMetadata> CreateFileAsync(Stream fileStream, string title, string parentPath)
public Task<FileMetadata> CreateFileAsync(Stream fileStream, string title, string parentPath)
{
var path = MakeDropboxPath(parentPath, title);
return await dropboxClient.Files.UploadAsync(path, WriteMode.Add.Instance, true, body: fileStream);
return dropboxClient.Files.UploadAsync(path, WriteMode.Add.Instance, true, body: fileStream);
}
public void DeleteItem(Metadata dropboxItem)
@ -236,9 +236,9 @@ namespace ASC.Files.Thirdparty.Dropbox
dropboxClient.Files.DeleteV2Async(dropboxItem.PathDisplay).Wait();
}
public async Task DeleteItemAsync(Metadata dropboxItem)
public Task DeleteItemAsync(Metadata dropboxItem)
{
await dropboxClient.Files.DeleteV2Async(dropboxItem.PathDisplay);
return dropboxClient.Files.DeleteV2Async(dropboxItem.PathDisplay);
}
public FolderMetadata MoveFolder(string dropboxFolderPath, string dropboxFolderPathTo, string folderName)
@ -324,9 +324,9 @@ namespace ASC.Files.Thirdparty.Dropbox
dropboxClient.Files.UploadSessionAppendV2Async(new UploadSessionCursor(dropboxSession, (ulong)offset), body: stream).Wait();
}
public async Task TransferAsync(string dropboxSession, long offset, Stream stream)
public Task TransferAsync(string dropboxSession, long offset, Stream stream)
{
await dropboxClient.Files.UploadSessionAppendV2Async(new UploadSessionCursor(dropboxSession, (ulong)offset), body: stream);
return dropboxClient.Files.UploadSessionAppendV2Async(new UploadSessionCursor(dropboxSession, (ulong)offset), body: stream);
}
public Metadata FinishResumableSession(string dropboxSession, string dropboxFolderPath, string fileName, long offset)
@ -335,10 +335,10 @@ namespace ASC.Files.Thirdparty.Dropbox
return FinishResumableSession(dropboxSession, dropboxFilePath, offset);
}
public async Task<Metadata> FinishResumableSessionAsync(string dropboxSession, string dropboxFolderPath, string fileName, long offset)
public Task<Metadata> FinishResumableSessionAsync(string dropboxSession, string dropboxFolderPath, string fileName, long offset)
{
var dropboxFilePath = MakeDropboxPath(dropboxFolderPath, fileName);
return await FinishResumableSessionAsync(dropboxSession, dropboxFilePath, offset);
return FinishResumableSessionAsync(dropboxSession, dropboxFilePath, offset);
}
public Metadata FinishResumableSession(string dropboxSession, string dropboxFilePath, long offset)

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

@ -86,9 +86,9 @@ namespace ASC.Files.Thirdparty.GoogleDrive
if (parentDriveId != null) await ProviderInfo.CacheResetAsync(parentDriveId).ConfigureAwait(false);
}
public async Task<File<string>> GetFileAsync(string fileId)
public Task<File<string>> GetFileAsync(string fileId)
{
return await GetFileAsync(fileId, 1).ConfigureAwait(false);
return GetFileAsync(fileId, 1);
}
public async Task<File<string>> GetFileAsync(string fileId, int fileVersion)
@ -248,9 +248,9 @@ namespace ASC.Files.Thirdparty.GoogleDrive
}
}
public override async Task<Stream> GetFileStreamAsync(File<string> file)
public override Task<Stream> GetFileStreamAsync(File<string> file)
{
return await GetFileStreamAsync(file, 0).ConfigureAwait(false);
return GetFileStreamAsync(file, 0);
}
public async Task<Stream> GetFileStreamAsync(File<string> file, long offset)
@ -304,9 +304,9 @@ namespace ASC.Files.Thirdparty.GoogleDrive
return ToFile(newDriveFile);
}
public async Task<File<string>> ReplaceFileVersionAsync(File<string> file, Stream fileStream)
public Task<File<string>> ReplaceFileVersionAsync(File<string> file, Stream fileStream)
{
return await SaveFileAsync(file, fileStream).ConfigureAwait(false);
return SaveFileAsync(file, fileStream);
}
public async Task DeleteFileAsync(string fileId)

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

@ -88,9 +88,9 @@ namespace ASC.Files.Thirdparty.GoogleDrive
return ToFolder(entries.FirstOrDefault(folder => folder.Name.Equals(title, StringComparison.InvariantCultureIgnoreCase)));
}
public async Task<Folder<string>> GetRootFolderByFileAsync(string fileId)
public Task<Folder<string>> GetRootFolderByFileAsync(string fileId)
{
return await GetRootFolderAsync("").ConfigureAwait(false);
return GetRootFolderAsync("");
}
public async IAsyncEnumerable<Folder<string>> GetFoldersAsync(string parentId)
@ -348,16 +348,16 @@ namespace ASC.Files.Thirdparty.GoogleDrive
return ToFolder(newDriveFolder);
}
public async Task<IDictionary<string, string>> CanMoveOrCopyAsync<TTo>(string[] folderIds, TTo to)
public Task<IDictionary<string, string>> CanMoveOrCopyAsync<TTo>(string[] folderIds, TTo to)
{
if (to is int tId)
{
return await CanMoveOrCopyAsync(folderIds, tId).ConfigureAwait(false);
return CanMoveOrCopyAsync(folderIds, tId);
}
if (to is string tsId)
{
return await CanMoveOrCopyAsync(folderIds, tsId).ConfigureAwait(false);
return CanMoveOrCopyAsync(folderIds, tsId);
}
throw new NotImplementedException();

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

@ -140,14 +140,14 @@ namespace ASC.Files.Thirdparty.GoogleDrive
}
}
public async Task InvalidateStorageAsync()
public Task InvalidateStorageAsync()
{
if (Wrapper != null)
{
Wrapper.Dispose();
}
await CacheResetAsync().ConfigureAwait(false);
return CacheResetAsync();
}
public void UpdateTitle(string newtitle)
@ -155,29 +155,29 @@ namespace ASC.Files.Thirdparty.GoogleDrive
CustomerTitle = newtitle;
}
internal async Task<DriveFile> GetDriveEntryAsync(string driveId)
internal Task<DriveFile> GetDriveEntryAsync(string driveId)
{
return await GoogleDriveProviderInfoHelper.GetDriveEntryAsync(Storage, ID, driveId).ConfigureAwait(false);
return GoogleDriveProviderInfoHelper.GetDriveEntryAsync(Storage, ID, driveId);
}
internal async Task<List<DriveFile>> GetDriveEntriesAsync(string parentDriveId, bool? folder = null)
internal Task<List<DriveFile>> GetDriveEntriesAsync(string parentDriveId, bool? folder = null)
{
return await GoogleDriveProviderInfoHelper.GetDriveEntriesAsync(Storage, ID, parentDriveId, folder).ConfigureAwait(false);
return GoogleDriveProviderInfoHelper.GetDriveEntriesAsync(Storage, ID, parentDriveId, folder);
}
internal async Task CacheResetAsync(DriveFile driveEntry)
internal Task CacheResetAsync(DriveFile driveEntry)
{
await GoogleDriveProviderInfoHelper.CacheResetAsync(driveEntry, ID).ConfigureAwait(false);
return GoogleDriveProviderInfoHelper.CacheResetAsync(driveEntry, ID);
}
internal async Task CacheResetAsync(string driveId = null, bool? childFolder = null)
internal Task CacheResetAsync(string driveId = null, bool? childFolder = null)
{
await GoogleDriveProviderInfoHelper.CacheResetAsync(DriveRootId, ID, driveId, childFolder).ConfigureAwait(false);
return GoogleDriveProviderInfoHelper.CacheResetAsync(DriveRootId, ID, driveId, childFolder);
}
internal async Task CacheResetChildsAsync(string parentDriveId, bool? childFolder = null)
internal Task CacheResetChildsAsync(string parentDriveId, bool? childFolder = null)
{
await GoogleDriveProviderInfoHelper.CacheResetChildsAsync(ID, parentDriveId, childFolder).ConfigureAwait(false);
return GoogleDriveProviderInfoHelper.CacheResetChildsAsync(ID, parentDriveId, childFolder);
}
}
@ -361,9 +361,9 @@ namespace ASC.Files.Thirdparty.GoogleDrive
}
}
internal async Task CacheResetChildsAsync(int id, string parentDriveId, bool? childFolder = null)
internal Task CacheResetChildsAsync(int id, string parentDriveId, bool? childFolder = null)
{
await CacheNotify.PublishAsync(new GoogleDriveCacheItem { ResetChilds = true, Key = id + "-" + parentDriveId, ChildFolder = childFolder ?? false, ChildFolderExist = childFolder.HasValue }, CacheNotifyAction.Remove).ConfigureAwait(false);
return CacheNotify.PublishAsync(new GoogleDriveCacheItem { ResetChilds = true, Key = id + "-" + parentDriveId, ChildFolder = childFolder ?? false, ChildFolderExist = childFolder.HasValue }, CacheNotifyAction.Remove);
}
}

18
products/ASC.Files/Core/Core/Thirdparty/GoogleDrive/GoogleDriveStorage.cs vendored
View File

@ -397,9 +397,9 @@ namespace ASC.Files.Thirdparty.GoogleDrive
_driveService.Files.Delete(entryId).Execute();
}
public async Task DeleteEntryAsync(string entryId)
public Task DeleteEntryAsync(string entryId)
{
await _driveService.Files.Delete(entryId).ExecuteAsync();
return _driveService.Files.Delete(entryId).ExecuteAsync();
}
public DriveFile InsertEntryIntoFolder(DriveFile entry, string folderId)
@ -410,12 +410,12 @@ namespace ASC.Files.Thirdparty.GoogleDrive
return request.Execute();
}
public async Task<DriveFile> InsertEntryIntoFolderAsync(DriveFile entry, string folderId)
public Task<DriveFile> InsertEntryIntoFolderAsync(DriveFile entry, string folderId)
{
var request = _driveService.Files.Update(FileConstructor(), entry.Id);
request.AddParents = folderId;
request.Fields = GoogleLoginProvider.FilesFields;
return await request.ExecuteAsync();
return request.ExecuteAsync();
}
public DriveFile RemoveEntryFromFolder(DriveFile entry, string folderId)
@ -426,12 +426,12 @@ namespace ASC.Files.Thirdparty.GoogleDrive
return request.Execute();
}
public async Task<DriveFile> RemoveEntryFromFolderAsync(DriveFile entry, string folderId)
public Task<DriveFile> RemoveEntryFromFolderAsync(DriveFile entry, string folderId)
{
var request = _driveService.Files.Update(FileConstructor(), entry.Id);
request.RemoveParents = folderId;
request.Fields = GoogleLoginProvider.FilesFields;
return await request.ExecuteAsync();
return request.ExecuteAsync();
}
public DriveFile CopyEntry(string toFolderId, string originEntryId)
@ -479,11 +479,11 @@ namespace ASC.Files.Thirdparty.GoogleDrive
return request.Execute();
}
public async Task<DriveFile> RenameEntryAsync(string fileId, string newTitle)
public Task<DriveFile> RenameEntryAsync(string fileId, string newTitle)
{
var request = _driveService.Files.Update(FileConstructor(newTitle), fileId);
request.Fields = GoogleLoginProvider.FilesFields;
return await request.ExecuteAsync();
return request.ExecuteAsync();
}
public DriveFile SaveStream(string fileId, Stream fileStream, string fileTitle)
@ -605,7 +605,7 @@ namespace ASC.Files.Thirdparty.GoogleDrive
request.Headers.Add("Authorization", "Bearer " + AccessToken);
var requestStream = await request.GetRequestStreamAsync();
requestStream.Write(bytes, 0, bytes.Length);
await requestStream.WriteAsync(bytes, 0, bytes.Length);
var uploadSession = new ResumableUploadSession(driveFile.Id, folderId, contentLength);
using (var response = await request.GetResponseAsync())

12
products/ASC.Files/Core/Core/Thirdparty/OneDrive/OneDriveFileDao.cs vendored
View File

@ -85,9 +85,9 @@ namespace ASC.Files.Thirdparty.OneDrive
if (parentId != null) await ProviderInfo.CacheResetAsync(parentId).ConfigureAwait(false);
}
public async Task<File<string>> GetFileAsync(string fileId)
public Task<File<string>> GetFileAsync(string fileId)
{
return await GetFileAsync(fileId, 1).ConfigureAwait(false);
return GetFileAsync(fileId, 1);
}
public async Task<File<string>> GetFileAsync(string fileId, int fileVersion)
@ -250,9 +250,9 @@ namespace ASC.Files.Thirdparty.OneDrive
}
}
public override async Task<Stream> GetFileStreamAsync(File<string> file)
public override Task<Stream> GetFileStreamAsync(File<string> file)
{
return await GetFileStreamAsync(file, 0).ConfigureAwait(false);
return GetFileStreamAsync(file, 0);
}
public async Task<Stream> GetFileStreamAsync(File<string> file, long offset)
@ -310,9 +310,9 @@ namespace ASC.Files.Thirdparty.OneDrive
return ToFile(newOneDriveFile);
}
public async Task<File<string>> ReplaceFileVersionAsync(File<string> file, Stream fileStream)
public Task<File<string>> ReplaceFileVersionAsync(File<string> file, Stream fileStream)
{
return await SaveFileAsync(file, fileStream).ConfigureAwait(false);
return SaveFileAsync(file, fileStream);
}
public async Task DeleteFileAsync(string fileId)

10
products/ASC.Files/Core/Core/Thirdparty/OneDrive/OneDriveFolderDao.cs vendored
View File

@ -88,9 +88,9 @@ namespace ASC.Files.Thirdparty.OneDrive
return ToFolder(items.FirstOrDefault(item => item.Name.Equals(title, StringComparison.InvariantCultureIgnoreCase) && item.Folder != null));
}
public async Task<Folder<string>> GetRootFolderByFileAsync(string fileId)
public Task<Folder<string>> GetRootFolderByFileAsync(string fileId)
{
return await GetRootFolderAsync(fileId).ConfigureAwait(false);
return GetRootFolderAsync(fileId);
}
public async IAsyncEnumerable<Folder<string>> GetFoldersAsync(string parentId)
@ -351,16 +351,16 @@ namespace ASC.Files.Thirdparty.OneDrive
return ToFolder(newOneDriveFolder);
}
public async Task<IDictionary<string, string>> CanMoveOrCopyAsync<TTo>(string[] folderIds, TTo to)
public Task<IDictionary<string, string>> CanMoveOrCopyAsync<TTo>(string[] folderIds, TTo to)
{
if (to is int tId)
{
return await CanMoveOrCopyAsync(folderIds, tId).ConfigureAwait(false);
return CanMoveOrCopyAsync(folderIds, tId);
}
if (to is string tsId)
{
return await CanMoveOrCopyAsync(folderIds, tsId).ConfigureAwait(false);
return CanMoveOrCopyAsync(folderIds, tsId);
}
throw new NotImplementedException();

16
products/ASC.Files/Core/Core/Thirdparty/OneDrive/OneDriveProviderInfo.cs vendored
View File

@ -111,14 +111,14 @@ namespace ASC.Files.Thirdparty.OneDrive
}
}
public async Task InvalidateStorageAsync()
public Task InvalidateStorageAsync()
{
if (Wrapper != null)
{
Wrapper.Dispose();
}
await CacheResetAsync().ConfigureAwait(false);
return CacheResetAsync();
}
public void UpdateTitle(string newtitle)
@ -126,19 +126,19 @@ namespace ASC.Files.Thirdparty.OneDrive
CustomerTitle = newtitle;
}
internal async Task<Item> GetOneDriveItemAsync(string itemId)
internal Task<Item> GetOneDriveItemAsync(string itemId)
{
return await OneDriveProviderInfoHelper.GetOneDriveItemAsync(Storage, ID, itemId).ConfigureAwait(false);
return OneDriveProviderInfoHelper.GetOneDriveItemAsync(Storage, ID, itemId);
}
internal async Task<List<Item>> GetOneDriveItemsAsync(string onedriveFolderId)
internal Task<List<Item>> GetOneDriveItemsAsync(string onedriveFolderId)
{
return await OneDriveProviderInfoHelper.GetOneDriveItemsAsync(Storage, ID, onedriveFolderId).ConfigureAwait(false);
return OneDriveProviderInfoHelper.GetOneDriveItemsAsync(Storage, ID, onedriveFolderId);
}
internal async Task CacheResetAsync(string onedriveId = null)
internal Task CacheResetAsync(string onedriveId = null)
{
await OneDriveProviderInfoHelper.CacheResetAsync(ID, onedriveId).ConfigureAwait(false);
return OneDriveProviderInfoHelper.CacheResetAsync(ID, onedriveId);
}
}

26
products/ASC.Files/Core/Core/Thirdparty/OneDrive/OneDriveStorage.cs vendored
View File

@ -215,7 +215,7 @@ namespace ASC.Files.Thirdparty.OneDrive
.Result;
}
public async Task<Item> CreateFolderAsync(string title, string parentId)
public Task<Item> CreateFolderAsync(string title, string parentId)
{
var newFolderItem = new Item
{
@ -223,7 +223,7 @@ namespace ASC.Files.Thirdparty.OneDrive
Name = title
};
return await GetItemRequest(parentId)
return GetItemRequest(parentId)
.Children
.Request()
.AddAsync(newFolderItem);
@ -241,9 +241,9 @@ namespace ASC.Files.Thirdparty.OneDrive
.Result;
}
public async Task<Item> CreateFileAsync(Stream fileStream, string title, string parentPath)
public Task<Item> CreateFileAsync(Stream fileStream, string title, string parentPath)
{
return await OnedriveClient
return OnedriveClient
.Drive
.Root
.ItemWithPath(MakeOneDrivePath(parentPath, title))
@ -261,9 +261,9 @@ namespace ASC.Files.Thirdparty.OneDrive
.DeleteAsync();
}
public async Task DeleteItemAsync(Item item)
public Task DeleteItemAsync(Item item)
{
await OnedriveClient
return OnedriveClient
.Drive
.Items[item.Id]
.Request()
@ -282,11 +282,11 @@ namespace ASC.Files.Thirdparty.OneDrive
.Result;
}
public async Task<Item> MoveItemAsync(string itemId, string newItemName, string toFolderId)
public Task<Item> MoveItemAsync(string itemId, string newItemName, string toFolderId)
{
var updateItem = new Item { ParentReference = new ItemReference { Id = toFolderId }, Name = newItemName };
return await OnedriveClient
return OnedriveClient
.Drive
.Items[itemId]
.Request()
@ -315,7 +315,7 @@ namespace ASC.Files.Thirdparty.OneDrive
.Request()
.PostAsync();
return copyMonitor.PollForOperationCompletionAsync(null, CancellationToken.None).Result;
return await copyMonitor.PollForOperationCompletionAsync(null, CancellationToken.None);
}
public Item RenameItem(string itemId, string newName)
@ -329,10 +329,10 @@ namespace ASC.Files.Thirdparty.OneDrive
.Result;
}
public async Task<Item> RenameItemAsync(string itemId, string newName)
public Task<Item> RenameItemAsync(string itemId, string newName)
{
var updateItem = new Item { Name = newName };
return await OnedriveClient
return OnedriveClient
.Drive
.Items[itemId]
.Request()
@ -350,9 +350,9 @@ namespace ASC.Files.Thirdparty.OneDrive
.Result;
}
public async Task<Item> SaveStreamAsync(string fileId, Stream fileStream)
public Task<Item> SaveStreamAsync(string fileId, Stream fileStream)
{
return await OnedriveClient
return OnedriveClient
.Drive
.Items[fileId]
.Content

4
products/ASC.Files/Core/Core/Thirdparty/ProviderAccountDao.cs vendored
View File

@ -116,10 +116,10 @@ namespace ASC.Files.Thirdparty
ThirdpartyConfiguration = thirdpartyConfiguration;
}
public virtual async Task<IProviderInfo> GetProviderInfoAsync(int linkId)
public virtual Task<IProviderInfo> GetProviderInfoAsync(int linkId)
{
var providersInfo = GetProvidersInfoInternalAsync(linkId);
return await providersInfo.SingleAsync().ConfigureAwait(false);
return providersInfo.SingleAsync().AsTask();
}
public virtual IAsyncEnumerable<IProviderInfo> GetProvidersInfoAsync()

12
products/ASC.Files/Core/Core/Thirdparty/ProviderDao/ProviderDaoBase.cs vendored
View File

@ -143,12 +143,12 @@ namespace ASC.Files.Thirdparty.ProviderDao
deleteSourceFile);
}
protected internal async Task<File<string>> PerformCrossDaoFileCopyAsync(string fromFileId, string toFolderId, bool deleteSourceFile)
protected internal Task<File<string>> PerformCrossDaoFileCopyAsync(string fromFileId, string toFolderId, bool deleteSourceFile)
{
var fromSelector = GetSelector(fromFileId);
var toSelector = GetSelector(toFolderId);
return await CrossDao.PerformCrossDaoFileCopyAsync(
return CrossDao.PerformCrossDaoFileCopyAsync(
fromFileId, fromSelector.GetFileDao(fromFileId), fromSelector.ConvertId,
toFolderId, toSelector.GetFileDao(toFolderId), toSelector.ConvertId,
deleteSourceFile);
@ -191,12 +191,12 @@ namespace ASC.Files.Thirdparty.ProviderDao
deleteSourceFolder, cancellationToken);
}
protected async Task<Folder<string>> PerformCrossDaoFolderCopyAsync(string fromFolderId, string toRootFolderId, bool deleteSourceFolder, CancellationToken? cancellationToken)
protected Task<Folder<string>> PerformCrossDaoFolderCopyAsync(string fromFolderId, string toRootFolderId, bool deleteSourceFolder, CancellationToken? cancellationToken)
{
var fromSelector = GetSelector(fromFolderId);
var toSelector = GetSelector(toRootFolderId);
return await CrossDao.PerformCrossDaoFolderCopyAsync(
return CrossDao.PerformCrossDaoFolderCopyAsync(
fromFolderId, fromSelector.GetFolderDao(fromFolderId), fromSelector.GetFileDao(fromFolderId), fromSelector.ConvertId,
toRootFolderId, toSelector.GetFolderDao(toRootFolderId), toSelector.GetFileDao(toRootFolderId), toSelector.ConvertId,
deleteSourceFolder, cancellationToken);
@ -212,11 +212,11 @@ namespace ASC.Files.Thirdparty.ProviderDao
deleteSourceFolder, cancellationToken);
}
protected async Task<Folder<int>> PerformCrossDaoFolderCopyAsync(string fromFolderId, int toRootFolderId, bool deleteSourceFolder, CancellationToken? cancellationToken)
protected Task<Folder<int>> PerformCrossDaoFolderCopyAsync(string fromFolderId, int toRootFolderId, bool deleteSourceFolder, CancellationToken? cancellationToken)
{
var fromSelector = GetSelector(fromFolderId);
return await CrossDao.PerformCrossDaoFolderCopyAsync(
return CrossDao.PerformCrossDaoFolderCopyAsync(
fromFolderId, fromSelector.GetFolderDao(fromFolderId), fromSelector.GetFileDao(fromFolderId), fromSelector.ConvertId,
toRootFolderId, ServiceProvider.GetService<IFolderDao<int>>(), ServiceProvider.GetService<IFileDao<int>>(), r => r,
deleteSourceFolder, cancellationToken);

58
products/ASC.Files/Core/Core/Thirdparty/ProviderDao/ProviderFileDao.cs vendored
View File

@ -52,11 +52,11 @@ namespace ASC.Files.Thirdparty.ProviderDao
}
public async Task InvalidateCacheAsync(string fileId)
public Task InvalidateCacheAsync(string fileId)
{
var selector = GetSelector(fileId);
var fileDao = selector.GetFileDao(fileId);
await fileDao.InvalidateCacheAsync(selector.ConvertId(fileId)).ConfigureAwait(false);
return fileDao.InvalidateCacheAsync(selector.ConvertId(fileId));
}
public async Task<File<string>> GetFileAsync(string fileId)
@ -118,11 +118,11 @@ namespace ASC.Files.Thirdparty.ProviderDao
return result;
}
public async Task<List<File<string>>> GetFileHistoryAsync(string fileId)
public Task<List<File<string>>> GetFileHistoryAsync(string fileId)
{
var selector = GetSelector(fileId);
var fileDao = selector.GetFileDao(fileId);
return await fileDao.GetFileHistoryAsync(selector.ConvertId(fileId)).ConfigureAwait(false);
return fileDao.GetFileHistoryAsync(selector.ConvertId(fileId));
}
public IAsyncEnumerable<File<string>> GetFilesAsync(IEnumerable<string> fileIds)
@ -200,9 +200,9 @@ namespace ASC.Files.Thirdparty.ProviderDao
}
}
public override async Task<Stream> GetFileStreamAsync(File<string> file)
public override Task<Stream> GetFileStreamAsync(File<string> file)
{
return await GetFileStreamAsync(file, 0).ConfigureAwait(false);
return GetFileStreamAsync(file, 0);
}
/// <summary>
@ -284,7 +284,7 @@ namespace ASC.Files.Thirdparty.ProviderDao
throw new ArgumentException("No file id or folder id toFolderId determine provider");
}
public async Task<File<string>> ReplaceFileVersionAsync(File<string> file, Stream fileStream)
public Task<File<string>> ReplaceFileVersionAsync(File<string> file, Stream fileStream)
{
if (file == null) throw new ArgumentNullException("file");
if (file.ID == null) throw new ArgumentException("No file id or folder id toFolderId determine provider");
@ -299,22 +299,22 @@ namespace ASC.Files.Thirdparty.ProviderDao
if (folderId != null) file.FolderID = selector.ConvertId(folderId);
var fileDao = selector.GetFileDao(fileId);
return await fileDao.ReplaceFileVersionAsync(file, fileStream).ConfigureAwait(false);
return fileDao.ReplaceFileVersionAsync(file, fileStream);
}
public async Task DeleteFileAsync(string fileId)
public Task DeleteFileAsync(string fileId)
{
var selector = GetSelector(fileId);
var fileDao = selector.GetFileDao(fileId);
await fileDao.DeleteFileAsync(selector.ConvertId(fileId)).ConfigureAwait(false);
return fileDao.DeleteFileAsync(selector.ConvertId(fileId));
}
public async Task<bool> IsExistAsync(string title, object folderId)
public Task<bool> IsExistAsync(string title, object folderId)
{
var selector = GetSelector(folderId.ToString());
var fileDao = selector.GetFileDao(folderId.ToString());
return await fileDao.IsExistAsync(title, selector.ConvertId(folderId.ToString())).ConfigureAwait(false);
return fileDao.IsExistAsync(title, selector.ConvertId(folderId.ToString()));
}
public async Task<TTo> MoveFileAsync<TTo>(string fileId, TTo toFolderId)
@ -366,51 +366,51 @@ namespace ASC.Files.Thirdparty.ProviderDao
throw new NotImplementedException();
}
public async Task<File<int>> CopyFileAsync(string fileId, int toFolderId)
public Task<File<int>> CopyFileAsync(string fileId, int toFolderId)
{
return await PerformCrossDaoFileCopyAsync(fileId, toFolderId, false).ConfigureAwait(false);
return PerformCrossDaoFileCopyAsync(fileId, toFolderId, false);
}
public async Task<File<string>> CopyFileAsync(string fileId, string toFolderId)
public Task<File<string>> CopyFileAsync(string fileId, string toFolderId)
{
var selector = GetSelector(fileId);
if (IsCrossDao(fileId, toFolderId))
{
return await PerformCrossDaoFileCopyAsync(fileId, toFolderId, false).ConfigureAwait(false);
return PerformCrossDaoFileCopyAsync(fileId, toFolderId, false);
}
var fileDao = selector.GetFileDao(fileId);
return await fileDao.CopyFileAsync(selector.ConvertId(fileId), selector.ConvertId(toFolderId)).ConfigureAwait(false);
return fileDao.CopyFileAsync(selector.ConvertId(fileId), selector.ConvertId(toFolderId));
}
public async Task<string> FileRenameAsync(File<string> file, string newTitle)
public Task<string> FileRenameAsync(File<string> file, string newTitle)
{
var selector = GetSelector(file.ID);
var fileDao = selector.GetFileDao(file.ID);
return await fileDao.FileRenameAsync(ConvertId(file), newTitle).ConfigureAwait(false);
return fileDao.FileRenameAsync(ConvertId(file), newTitle);
}
public async Task<string> UpdateCommentAsync(string fileId, int fileVersion, string comment)
public Task<string> UpdateCommentAsync(string fileId, int fileVersion, string comment)
{
var selector = GetSelector(fileId);
var fileDao = selector.GetFileDao(fileId);
return await fileDao.UpdateCommentAsync(selector.ConvertId(fileId), fileVersion, comment).ConfigureAwait(false);
return fileDao.UpdateCommentAsync(selector.ConvertId(fileId), fileVersion, comment);
}
public async Task CompleteVersionAsync(string fileId, int fileVersion)
public Task CompleteVersionAsync(string fileId, int fileVersion)
{
var selector = GetSelector(fileId);
var fileDao = selector.GetFileDao(fileId);
await fileDao.CompleteVersionAsync(selector.ConvertId(fileId), fileVersion).ConfigureAwait(false);
return fileDao.CompleteVersionAsync(selector.ConvertId(fileId), fileVersion);
}
public async Task ContinueVersionAsync(string fileId, int fileVersion)
public Task ContinueVersionAsync(string fileId, int fileVersion)
{
var selector = GetSelector(fileId);
var fileDao = selector.GetFileDao(fileId);
await fileDao.ContinueVersionAsync(selector.ConvertId(fileId), fileVersion).ConfigureAwait(false);
return fileDao.ContinueVersionAsync(selector.ConvertId(fileId), fileVersion);
}
public bool UseTrashForRemove(File<string> file)
@ -422,10 +422,10 @@ namespace ASC.Files.Thirdparty.ProviderDao
#region chunking
public async Task<ChunkedUploadSession<string>> CreateUploadSessionAsync(File<string> file, long contentLength)
public Task<ChunkedUploadSession<string>> CreateUploadSessionAsync(File<string> file, long contentLength)
{
var fileDao = GetFileDao(file);
return await fileDao.CreateUploadSessionAsync(ConvertId(file), contentLength).ConfigureAwait(false);
return fileDao.CreateUploadSessionAsync(ConvertId(file), contentLength);
}
public async Task<File<string>> UploadChunkAsync(ChunkedUploadSession<string> uploadSession, Stream chunkStream, long chunkLength)
@ -436,11 +436,11 @@ namespace ASC.Files.Thirdparty.ProviderDao
return uploadSession.File;
}
public async Task AbortUploadSessionAsync(ChunkedUploadSession<string> uploadSession)
public Task AbortUploadSessionAsync(ChunkedUploadSession<string> uploadSession)
{
var fileDao = GetFileDao(uploadSession.File);
uploadSession.File = ConvertId(uploadSession.File);
await fileDao.AbortUploadSessionAsync(uploadSession).ConfigureAwait(false);
return fileDao.AbortUploadSessionAsync(uploadSession);
}
private IFileDao<string> GetFileDao(File<string> file)

42
products/ASC.Files/Core/Core/Thirdparty/ProviderDao/ProviderFolderDao.cs vendored
View File

@ -67,24 +67,24 @@ namespace ASC.Files.Thirdparty.ProviderDao
return result;
}
public async Task<Folder<string>> GetFolderAsync(string title, string parentId)
public Task<Folder<string>> GetFolderAsync(string title, string parentId)
{
var selector = GetSelector(parentId);
return await selector.GetFolderDao(parentId).GetFolderAsync(title, selector.ConvertId(parentId)).ConfigureAwait(false);
return selector.GetFolderDao(parentId).GetFolderAsync(title, selector.ConvertId(parentId));
}
public async Task<Folder<string>> GetRootFolderAsync(string folderId)
public Task<Folder<string>> GetRootFolderAsync(string folderId)
{
var selector = GetSelector(folderId);
var folderDao = selector.GetFolderDao(folderId);
return await folderDao.GetRootFolderAsync(selector.ConvertId(folderId)).ConfigureAwait(false);
return folderDao.GetRootFolderAsync(selector.ConvertId(folderId));
}
public async Task<Folder<string>> GetRootFolderByFileAsync(string fileId)
public Task<Folder<string>> GetRootFolderByFileAsync(string fileId)
{
var selector = GetSelector(fileId);
var folderDao = selector.GetFolderDao(fileId);
return await folderDao.GetRootFolderByFileAsync(selector.ConvertId(fileId)).ConfigureAwait(false);
return folderDao.GetRootFolderByFileAsync(selector.ConvertId(fileId));
}
public IAsyncEnumerable<Folder<string>> GetFoldersAsync(string parentId)
@ -136,11 +136,11 @@ namespace ASC.Files.Thirdparty.ProviderDao
return result.Distinct();
}
public async Task<List<Folder<string>>> GetParentFoldersAsync(string folderId)
public Task<List<Folder<string>>> GetParentFoldersAsync(string folderId)
{
var selector = GetSelector(folderId);
var folderDao = selector.GetFolderDao(folderId);
return await folderDao.GetParentFoldersAsync(selector.ConvertId(folderId)).ConfigureAwait(false);
return folderDao.GetParentFoldersAsync(selector.ConvertId(folderId));
}
@ -172,11 +172,11 @@ namespace ASC.Files.Thirdparty.ProviderDao
throw new ArgumentException("No folder id or parent folder id to determine provider");
}
public async Task DeleteFolderAsync(string folderId)
public Task DeleteFolderAsync(string folderId)
{
var selector = GetSelector(folderId);
var folderDao = selector.GetFolderDao(folderId);
await folderDao.DeleteFolderAsync(selector.ConvertId(folderId)).ConfigureAwait(false);
return folderDao.DeleteFolderAsync(selector.ConvertId(folderId));
}
public async Task<TTo> MoveFolderAsync<TTo>(string folderId, TTo toFolderId, CancellationToken? cancellationToken)
@ -227,9 +227,9 @@ namespace ASC.Files.Thirdparty.ProviderDao
throw new NotImplementedException();
}
public async Task<Folder<int>> CopyFolderAsync(string folderId, int toFolderId, CancellationToken? cancellationToken)
public Task<Folder<int>> CopyFolderAsync(string folderId, int toFolderId, CancellationToken? cancellationToken)
{
return await PerformCrossDaoFolderCopyAsync(folderId, toFolderId, false, cancellationToken).ConfigureAwait(false);
return PerformCrossDaoFolderCopyAsync(folderId, toFolderId, false, cancellationToken);
}
public async Task<Folder<string>> CopyFolderAsync(string folderId, string toFolderId, CancellationToken? cancellationToken)
@ -241,16 +241,16 @@ namespace ASC.Files.Thirdparty.ProviderDao
: await folderDao.CopyFolderAsync(selector.ConvertId(folderId), selector.ConvertId(toFolderId), null).ConfigureAwait(false);
}
public async Task<IDictionary<string, string>> CanMoveOrCopyAsync<TTo>(string[] folderIds, TTo to)
public Task<IDictionary<string, string>> CanMoveOrCopyAsync<TTo>(string[] folderIds, TTo to)
{
if (to is int tId)
{
return await CanMoveOrCopyAsync(folderIds, tId).ConfigureAwait(false);
return CanMoveOrCopyAsync(folderIds, tId);
}
if (to is string tsId)
{
return await CanMoveOrCopyAsync(folderIds, tsId).ConfigureAwait(false);
return CanMoveOrCopyAsync(folderIds, tsId);
}
throw new NotImplementedException();
@ -274,28 +274,28 @@ namespace ASC.Files.Thirdparty.ProviderDao
return await folderDao.CanMoveOrCopyAsync(matchedIds, to).ConfigureAwait(false);
}
public async Task<string> RenameFolderAsync(Folder<string> folder, string newTitle)
public Task<string> RenameFolderAsync(Folder<string> folder, string newTitle)
{
var folderId = folder.ID;
var selector = GetSelector(folderId);
folder.ID = selector.ConvertId(folderId);
folder.FolderID = selector.ConvertId(folder.FolderID);
var folderDao = selector.GetFolderDao(folderId);
return await folderDao.RenameFolderAsync(folder, newTitle).ConfigureAwait(false);
return folderDao.RenameFolderAsync(folder, newTitle);
}
public async Task<int> GetItemsCountAsync(string folderId)
public Task<int> GetItemsCountAsync(string folderId)
{
var selector = GetSelector(folderId);
var folderDao = selector.GetFolderDao(folderId);
return await folderDao.GetItemsCountAsync(selector.ConvertId(folderId)).ConfigureAwait(false);
return folderDao.GetItemsCountAsync(selector.ConvertId(folderId));
}
public async Task<bool> IsEmptyAsync(string folderId)
public Task<bool> IsEmptyAsync(string folderId)
{
var selector = GetSelector(folderId);
var folderDao = selector.GetFolderDao(folderId);
return await folderDao.IsEmptyAsync(selector.ConvertId(folderId)).ConfigureAwait(false);
return folderDao.IsEmptyAsync(selector.ConvertId(folderId));
}
public bool UseTrashForRemove(Folder<string> folder)

4
products/ASC.Files/Core/Core/Thirdparty/ProviderDao/ProviderTagDao.cs vendored
View File

@ -131,9 +131,9 @@ namespace ASC.Files.Thirdparty.ProviderDao
return TagDao.GetTagsAsync(entryID, entryType, tagType);
}
public async Task<IDictionary<object, IEnumerable<Tag>>> GetTagsAsync(Guid subject, IEnumerable<TagType> tagType, IEnumerable<FileEntry<string>> fileEntries)
public Task<IDictionary<object, IEnumerable<Tag>>> GetTagsAsync(Guid subject, IEnumerable<TagType> tagType, IEnumerable<FileEntry<string>> fileEntries)
{
return await TagDao.GetTagsAsync(subject, tagType, fileEntries).ConfigureAwait(false);
return TagDao.GetTagsAsync(subject, tagType, fileEntries);
}
#endregion

4
products/ASC.Files/Core/Core/Thirdparty/SharePoint/SharePointDaoBase.cs vendored
View File

@ -223,9 +223,9 @@ namespace ASC.Files.Thirdparty.SharePoint
return MappingID(id, false);
}
protected async Task<string> MappingIDAsync(string id)
protected Task<string> MappingIDAsync(string id)
{
return await MappingIDAsync(id, false);
return MappingIDAsync(id, false);
}
protected override string MakeId(string path = null)

20
products/ASC.Files/Core/Core/Thirdparty/SharePoint/SharePointFileDao.cs vendored
View File

@ -73,14 +73,14 @@ namespace ASC.Files.Thirdparty.SharePoint
FileDao = fileDao;
}
public async Task InvalidateCacheAsync(string fileId)
public Task InvalidateCacheAsync(string fileId)
{
await ProviderInfo.InvalidateStorageAsync().ConfigureAwait(false);
return ProviderInfo.InvalidateStorageAsync();
}
public async Task<File<string>> GetFileAsync(string fileId)
public Task<File<string>> GetFileAsync(string fileId)
{
return await GetFileAsync(fileId, 1).ConfigureAwait(false);
return GetFileAsync(fileId, 1);
}
public async Task<File<string>> GetFileAsync(string fileId, int fileVersion)
@ -241,9 +241,9 @@ namespace ASC.Files.Thirdparty.SharePoint
}
}
public override async Task<Stream> GetFileStreamAsync(File<string> file)
public override Task<Stream> GetFileStreamAsync(File<string> file)
{
return await GetFileStreamAsync(file, 0).ConfigureAwait(false);
return GetFileStreamAsync(file, 0);
}
public async Task<Stream> GetFileStreamAsync(File<string> file, long offset)
@ -297,14 +297,14 @@ namespace ASC.Files.Thirdparty.SharePoint
return null;
}
public async Task<File<string>> ReplaceFileVersionAsync(File<string> file, Stream fileStream)
public Task<File<string>> ReplaceFileVersionAsync(File<string> file, Stream fileStream)
{
return await SaveFileAsync(file, fileStream).ConfigureAwait(false);
return SaveFileAsync(file, fileStream);
}
public async Task DeleteFileAsync(string fileId)
public Task DeleteFileAsync(string fileId)
{
await ProviderInfo.DeleteFileAsync(fileId).ConfigureAwait(false);
return ProviderInfo.DeleteFileAsync(fileId);
}
public async Task<bool> IsExistAsync(string title, object folderId)

6
products/ASC.Files/Core/Core/Thirdparty/SharePoint/SharePointFolderDao.cs vendored
View File

@ -318,16 +318,16 @@ namespace ASC.Files.Thirdparty.SharePoint
return moved;
}
public async Task<IDictionary<string, string>> CanMoveOrCopyAsync<TTo>(string[] folderIds, TTo to)
public Task<IDictionary<string, string>> CanMoveOrCopyAsync<TTo>(string[] folderIds, TTo to)
{
if (to is int tId)
{
return await CanMoveOrCopyAsync(folderIds, tId).ConfigureAwait(false);
return CanMoveOrCopyAsync(folderIds, tId);
}
if (to is string tsId)
{
return await CanMoveOrCopyAsync(folderIds, tsId).ConfigureAwait(false);
return CanMoveOrCopyAsync(folderIds, tsId);
}
throw new NotImplementedException();

28
products/ASC.Files/Core/Core/Thirdparty/SharePoint/SharePointProviderInfo.cs vendored
View File

@ -93,14 +93,14 @@ namespace ASC.Files.Thirdparty.SharePoint
}
}
public async Task InvalidateStorageAsync()
public Task InvalidateStorageAsync()
{
if (clientContext != null)
{
clientContext.Dispose();
}
await SharePointProviderInfoHelper.InvalidateAsync().ConfigureAwait(false);
return SharePointProviderInfoHelper.InvalidateAsync();
}
public void UpdateTitle(string newtitle)
@ -400,9 +400,9 @@ namespace ASC.Files.Thirdparty.SharePoint
return folder;
}
public async Task<Folder> GetParentFolderAsync(string serverRelativeUrl)
public Task<Folder> GetParentFolderAsync(string serverRelativeUrl)
{
return await GetFolderByIdAsync(GetParentFolderId(serverRelativeUrl)).ConfigureAwait(false);
return GetFolderByIdAsync(GetParentFolderId(serverRelativeUrl));
}
public async Task<IEnumerable<File>> GetFolderFilesAsync(object id)
@ -461,16 +461,16 @@ namespace ASC.Files.Thirdparty.SharePoint
if (delete)
{
folder.Folders.ToList().ForEach(r => MoveFolderAsync(r.ServerRelativeUrl, newUrl).Wait());
folder.Files.ToList().ForEach(r => MoveFileAsync(r.ServerRelativeUrl, newUrl).Wait());
folder.Folders.ToList().ForEach(async r => await MoveFolderAsync(r.ServerRelativeUrl, newUrl));
folder.Files.ToList().ForEach(async r => await MoveFileAsync(r.ServerRelativeUrl, newUrl));
folder.DeleteObject();
clientContext.ExecuteQuery();
}
else
{
folder.Folders.ToList().ForEach(r => CopyFolderAsync(r.ServerRelativeUrl, newUrl).Wait());
folder.Files.ToList().ForEach(r => CopyFileAsync(r.ServerRelativeUrl, newUrl).Wait());
folder.Folders.ToList().ForEach(async r => await CopyFolderAsync(r.ServerRelativeUrl, newUrl));
folder.Files.ToList().ForEach(async r => await CopyFileAsync(r.ServerRelativeUrl, newUrl));
}
return newFolder;
@ -624,14 +624,14 @@ namespace ASC.Files.Thirdparty.SharePoint
}, CacheNotifyAction.Remove);
}
public async Task InvalidateAsync()
public Task InvalidateAsync()
{
await Notify.PublishAsync(new SharePointProviderCacheItem { }, CacheNotifyAction.Remove).ConfigureAwait(false);
return Notify.PublishAsync(new SharePointProviderCacheItem { }, CacheNotifyAction.Remove);
}
public async Task PublishFolderAsync(string id)
public Task PublishFolderAsync(string id)
{
await Notify.PublishAsync(new SharePointProviderCacheItem { FolderKey = id }, CacheNotifyAction.Remove).ConfigureAwait(false);
return Notify.PublishAsync(new SharePointProviderCacheItem { FolderKey = id }, CacheNotifyAction.Remove);
}
public async Task PublishFolderAsync(string id1, string id2)
@ -646,9 +646,9 @@ namespace ASC.Files.Thirdparty.SharePoint
await PublishFolderAsync(id3).ConfigureAwait(false);
}
public async Task PublishFileAsync(string fileId, string folderId)
public Task PublishFileAsync(string fileId, string folderId)
{
await Notify.PublishAsync(new SharePointProviderCacheItem { FileKey = fileId, FolderKey = folderId }, CacheNotifyAction.Remove).ConfigureAwait(false);
return Notify.PublishAsync(new SharePointProviderCacheItem { FileKey = fileId, FolderKey = folderId }, CacheNotifyAction.Remove);
}
public async Task CreateFolderAsync(string id, string parentFolderId, Folder folder)

4
products/ASC.Files/Core/Core/Thirdparty/Sharpbox/SharpBoxDaoBase.cs vendored
View File

@ -160,9 +160,9 @@ namespace ASC.Files.Thirdparty.Sharpbox
return MappingID(id, false);
}
protected async Task<string> MappingIDAsync(string id)
protected Task<string> MappingIDAsync(string id)
{
return await MappingIDAsync(id, false);
return MappingIDAsync(id, false);
}
protected void UpdatePathInDB(string oldValue, string newValue)

20
products/ASC.Files/Core/Core/Thirdparty/Sharpbox/SharpBoxFileDao.cs vendored
View File

@ -82,14 +82,14 @@ namespace ASC.Files.Thirdparty.Sharpbox
FileDao = fileDao;
}
public async Task InvalidateCacheAsync(string fileId)
public Task InvalidateCacheAsync(string fileId)
{
await ProviderInfo.InvalidateStorageAsync();
return ProviderInfo.InvalidateStorageAsync();
}
public async Task<File<string>> GetFileAsync(string fileId)
public Task<File<string>> GetFileAsync(string fileId)
{
return await GetFileAsync(fileId, 1).ConfigureAwait(false);
return GetFileAsync(fileId, 1);
}
public Task<File<string>> GetFileAsync(string fileId, int fileVersion)
@ -288,9 +288,9 @@ namespace ASC.Files.Thirdparty.Sharpbox
return Task.FromResult(false);
}
public override async Task<Stream> GetFileStreamAsync(File<string> file)
public override Task<Stream> GetFileStreamAsync(File<string> file)
{
return await GetFileStreamAsync(file, 0).ConfigureAwait(false);
return GetFileStreamAsync(file, 0);
}
public async Task<File<string>> SaveFileAsync(File<string> file, Stream fileStream)
@ -343,9 +343,9 @@ namespace ASC.Files.Thirdparty.Sharpbox
return ToFile(entry);
}
public async Task<File<string>> ReplaceFileVersionAsync(File<string> file, Stream fileStream)
public Task<File<string>> ReplaceFileVersionAsync(File<string> file, Stream fileStream)
{
return await SaveFileAsync(file, fileStream).ConfigureAwait(false);
return SaveFileAsync(file, fileStream);
}
public async Task DeleteFileAsync(string fileId)
@ -394,10 +394,10 @@ namespace ASC.Files.Thirdparty.Sharpbox
ProviderInfo.Storage.DeleteFileSystemEntry(file);
}
public async Task<bool> IsExistAsync(string title, object folderId)
public Task<bool> IsExistAsync(string title, object folderId)
{
var folder = ProviderInfo.Storage.GetFolder(MakePath(folderId));
return await IsExistAsync(title, folder).ConfigureAwait(false);
return IsExistAsync(title, folder);
}
public Task<bool> IsExistAsync(string title, ICloudDirectoryEntry folder)

6
products/ASC.Files/Core/Core/Thirdparty/Sharpbox/SharpBoxFolderDao.cs vendored
View File

@ -362,16 +362,16 @@ namespace ASC.Files.Thirdparty.Sharpbox
return Task.FromResult(ToFolder(GetFolderById(toFolderId).OfType<ICloudDirectoryEntry>().FirstOrDefault(x => x.Name == folder.Name)));
}
public async Task<IDictionary<string, string>> CanMoveOrCopyAsync<TTo>(string[] folderIds, TTo to)
public Task<IDictionary<string, string>> CanMoveOrCopyAsync<TTo>(string[] folderIds, TTo to)
{
if (to is int tId)
{
return await CanMoveOrCopyAsync(folderIds, tId).ConfigureAwait(false);
return CanMoveOrCopyAsync(folderIds, tId);
}
if (to is string tsId)
{
return await CanMoveOrCopyAsync(folderIds, tsId).ConfigureAwait(false);
return CanMoveOrCopyAsync(folderIds, tsId);
}
throw new NotImplementedException();

12
products/ASC.Files/Core/HttpHandlers/ChunkedUploaderHandler.cs
View File

@ -222,21 +222,21 @@ namespace ASC.Web.Files.HttpHandlers
return false;
}
private static async Task WriteError(HttpContext context, string message)
private static Task WriteError(HttpContext context, string message)
{
await WriteResponse(context, false, null, message, (int)HttpStatusCode.OK);
return WriteResponse(context, false, null, message, (int)HttpStatusCode.OK);
}
private static async Task WriteSuccess(HttpContext context, object data, int statusCode = (int)HttpStatusCode.OK)
private static Task WriteSuccess(HttpContext context, object data, int statusCode = (int)HttpStatusCode.OK)
{
await WriteResponse(context, true, data, string.Empty, statusCode);
return WriteResponse(context, true, data, string.Empty, statusCode);
}
private static async Task WriteResponse(HttpContext context, bool success, object data, string message, int statusCode)
private static Task WriteResponse(HttpContext context, bool success, object data, string message, int statusCode)
{
context.Response.StatusCode = statusCode;
context.Response.ContentType = "application/json";
await context.Response.WriteAsync(JsonConvert.SerializeObject(new { success, data, message }));
return context.Response.WriteAsync(JsonConvert.SerializeObject(new { success, data, message }));
}
private static object ToResponseObject<T>(File<T> file)

26
products/ASC.Files/Core/HttpHandlers/FileHandler.ashx.cs
View File

@ -389,7 +389,7 @@ namespace ASC.Web.Files
var store = GlobalStore.GetStore();
if (!store.IsFile(mp4Path))
{
fileStream = fileDao.GetFileStreamAsync(file).Result;
fileStream = await fileDao.GetFileStreamAsync(file);
Logger.InfoFormat("Converting {0} (fileId: {1}) to mp4", file.Title, file.ID);
var stream = await FFmpegService.Convert(fileStream, ext);
@ -407,14 +407,14 @@ namespace ASC.Web.Files
{
if (!FileConverter.EnableConvert(file, ext))
{
if (!readLink && fileDao.IsSupportedPreSignedUriAsync(file).Result)
if (!readLink && await fileDao.IsSupportedPreSignedUriAsync(file))
{
context.Response.Redirect(fileDao.GetPreSignedUriAsync(file, TimeSpan.FromHours(1)).Result.ToString(), false);
context.Response.Redirect((await fileDao.GetPreSignedUriAsync(file, TimeSpan.FromHours(1))).ToString(), false);
return;
}
fileStream = fileDao.GetFileStreamAsync(file).Result; // getStream to fix file.ContentLength
fileStream = await fileDao.GetFileStreamAsync(file); // getStream to fix file.ContentLength
if (fileStream.CanSeek)
{
@ -440,14 +440,14 @@ namespace ASC.Web.Files
}
else
{
if (!readLink && fileDao.IsSupportedPreSignedUriAsync(file).Result)
if (!readLink && await fileDao.IsSupportedPreSignedUriAsync(file))
{
context.Response.Redirect(fileDao.GetPreSignedUriAsync(file, TimeSpan.FromHours(1)).Result.ToString(), true);
context.Response.Redirect((await fileDao.GetPreSignedUriAsync(file, TimeSpan.FromHours(1))).ToString(), true);
return;
}
fileStream = fileDao.GetFileStreamAsync(file).Result; // getStream to fix file.ContentLength
fileStream = await fileDao.GetFileStreamAsync(file); // getStream to fix file.ContentLength
long offset = 0;
var length = file.ContentLength;
@ -660,8 +660,8 @@ namespace ASC.Web.Files
|| version > 0 && file.Version != version)
{
file = version > 0
? fileDao.GetFileAsync(id, version).Result
: fileDao.GetFileAsync(id).Result;
? await fileDao.GetFileAsync(id, version)
: await fileDao.GetFileAsync(id);
}
if (file == null)
@ -686,7 +686,7 @@ namespace ASC.Web.Files
context.Response.Headers.Add("Content-Disposition", ContentDispositionUtil.GetHeaderValue(file.Title));
context.Response.ContentType = MimeMapping.GetMimeMapping(file.Title);
using var stream = fileDao.GetFileStreamAsync(file).Result;
using var stream = await fileDao.GetFileStreamAsync(file);
context.Response.Headers.Add("Content-Length",
stream.CanSeek
? stream.Length.ToString(CultureInfo.InvariantCulture)
@ -974,8 +974,8 @@ namespace ASC.Web.Files
{
var fileDao = DaoFactory.GetFileDao<T>();
var file = int.TryParse(context.Request.Query[FilesLinkUtility.Version], out var version) && version > 0
? fileDao.GetFileAsync(id, version).Result
: fileDao.GetFileAsync(id).Result;
? await fileDao.GetFileAsync(id, version)
: await fileDao.GetFileAsync(id);
if (file == null)
{
@ -1078,7 +1078,7 @@ namespace ASC.Web.Files
Folder<T> folder;
var folderDao = DaoFactory.GetFolderDao<T>();
folder = folderDao.GetFolderAsync(folderId).Result;
folder = await folderDao.GetFolderAsync(folderId);
if (folder == null) throw new HttpException((int)HttpStatusCode.NotFound, FilesCommonResource.ErrorMassage_FolderNotFound);
if (!FileSecurity.CanCreate(folder)) throw new HttpException((int)HttpStatusCode.Forbidden, FilesCommonResource.ErrorMassage_SecurityException_Create);

4
products/ASC.Files/Core/HttpHandlers/ThirdPartyAppHandler.ashx.cs
View File

@ -56,12 +56,12 @@ namespace ASC.Web.Files.HttpHandlers
ServiceProvider = serviceProvider;
}
public async Task Invoke(HttpContext context)
public Task Invoke(HttpContext context)
{
using var scope = ServiceProvider.CreateScope();
var thirdPartyAppHandlerService = scope.ServiceProvider.GetService<ThirdPartyAppHandlerService>();
thirdPartyAppHandlerService.Invoke(context);
await Next.Invoke(context);
return Next.Invoke(context);
}
}

2
products/ASC.Files/Core/Model/FileWrapper.cs
View File

@ -214,7 +214,7 @@ namespace ASC.Api.Documents
return result;
}
public async Task<FileWrapper<T>> GetAsync<T>(File<T> file, List<Tuple<FileEntry<T>, bool>> folders = null)
public async ValueTask<FileWrapper<T>> GetAsync<T>(File<T> file, List<Tuple<FileEntry<T>, bool>> folders = null)
{
var result = GetFileWrapper(file);

13
products/ASC.Files/Core/Model/FolderContentWrapper.cs
View File

@ -242,11 +242,16 @@ namespace ASC.Api.Documents
return result;
async Task<List<Tuple<FileEntry<T1>, bool>>> GetFoldersIntWithRightsAsync<T1>()
async ValueTask<List<Tuple<FileEntry<T1>, bool>>> GetFoldersIntWithRightsAsync<T1>()
{
var folderDao = DaoFactory.GetFolderDao<T1>();
var folders = await folderDao.GetFoldersAsync(folderItems.Entries.OfType<FileEntry<T1>>().Select(r => r.FolderID).Distinct()).ToListAsync();
return FileSecurity.CanRead(folders);
var ids = folderItems.Entries.OfType<FileEntry<T1>>().Select(r => r.FolderID).Distinct();
if (ids.Any())
{
var folderDao = DaoFactory.GetFolderDao<T1>();
var folders = await folderDao.GetFoldersAsync(ids).ToListAsync();
return FileSecurity.CanRead(folders);
}
return new List<Tuple<FileEntry<T1>, bool>>();
}
}
}

6
products/ASC.Files/Core/Services/WCFService/FileOperations/FileDeleteOperation.cs
View File

@ -127,7 +127,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
protected override async Task DoAsync(IServiceScope scope)
{
var folderDao = scope.ServiceProvider.GetService<IFolderDao<int>>();
_trashId = folderDao.GetFolderIDTrashAsync(true).Result;
_trashId = await folderDao.GetFolderIDTrashAsync(true);
Folder<T> root = null;
if (0 < Folders.Count)
@ -281,7 +281,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
var folders = await FolderDao.GetFoldersAsync(folder.ID).ToListAsync();
await DeleteFoldersAsync(folders.Select(f => f.ID).ToList(), scope);
if (FolderDao.IsEmptyAsync(folder.ID).Result)
if (await FolderDao.IsEmptyAsync(folder.ID))
{
await FolderDao.DeleteFolderAsync(folder.ID);
filesMessageService.Send(folder, _headers, MessageAction.FolderDeleted, folder.Title);
@ -396,7 +396,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
if (file.ThumbnailStatus == Thumbnail.Waiting)
{
file.ThumbnailStatus = Thumbnail.NotRequired;
FileDao.SaveThumbnailAsync(file, null).Wait();
await FileDao.SaveThumbnailAsync(file, null);
}
}
else

2
products/ASC.Files/Core/Services/WCFService/FileOperations/FileDownloadOperation.cs
View File

@ -573,7 +573,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
}
else
{
using (var readStream = FileDao.GetFileStreamAsync(file).Result)
using (var readStream = await FileDao.GetFileStreamAsync(file))
{
compressTo.PutStream(readStream);

10
products/ASC.Files/Core/Services/WCFService/FileOperations/FileMoveCopyOperation.cs
View File

@ -483,7 +483,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
if (FolderDao.UseRecursiveOperation(folder.ID, toFolderId))
{
await MoveOrCopyFilesAsync(scope, FileDao.GetFilesAsync(folder.ID).Result, newFolder, copy);
await MoveOrCopyFilesAsync(scope, await FileDao.GetFilesAsync(folder.ID), newFolder, copy);
await MoveOrCopyFoldersAsync(scope, await FolderDao.GetFoldersAsync(folder.ID).Select(f => f.ID).ToListAsync(), newFolder, copy);
if (!copy)
@ -492,7 +492,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
{
Error = FilesCommonResource.ErrorMassage_SecurityException_MoveFolder;
}
else if (FolderDao.IsEmptyAsync(folder.ID).Result)
else if (await FolderDao.IsEmptyAsync(folder.ID))
{
await FolderDao.DeleteFolderAsync(folder.ID);
if (ProcessedFolder(folderId))
@ -925,7 +925,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
if (file.RootFolderType == FolderType.TRASH && newFile.ThumbnailStatus == Thumbnail.NotRequired)
{
newFile.ThumbnailStatus = Thumbnail.Waiting;
fileDao.SaveThumbnailAsync(newFile, null).Wait();
await fileDao.SaveThumbnailAsync(newFile, null);
}
@ -977,9 +977,9 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
if (file.ThumbnailStatus == Thumbnail.Created)
{
using (var thumbnail = FileDao.GetThumbnailAsync(file).Result)
using (var thumbnail = await FileDao.GetThumbnailAsync(file))
{
fileDao.SaveThumbnailAsync(newFile, thumbnail).Wait();
await fileDao.SaveThumbnailAsync(newFile, thumbnail);
}
newFile.ThumbnailStatus = Thumbnail.Created;
}

4
products/ASC.Files/Core/Utils/ChunkedUploadSessionHolder.cs
View File

@ -125,9 +125,9 @@ namespace ASC.Web.Files.Utils
return CommonSessionHolder().UploadSingleChunk(uploadSession, stream, chunkLength);
}
public async Task<Stream> UploadSingleChunkAsync<T>(ChunkedUploadSession<T> uploadSession, Stream stream, long chunkLength)
public Task<Stream> UploadSingleChunkAsync<T>(ChunkedUploadSession<T> uploadSession, Stream stream, long chunkLength)
{
return await CommonSessionHolder().UploadSingleChunkAsync(uploadSession, stream, chunkLength);
return CommonSessionHolder().UploadSingleChunkAsync(uploadSession, stream, chunkLength);
}
private CommonChunkedUploadSessionHolder CommonSessionHolder(bool currentTenant = true)

20
products/ASC.Files/Core/Utils/EntryManager.cs
View File

@ -142,10 +142,10 @@ namespace ASC.Web.Files.Utils
return GetBreadCrumbs(folderId, folderDao);
}
public async Task<List<FileEntry>> GetBreadCrumbsAsync<T>(T folderId)
public Task<List<FileEntry>> GetBreadCrumbsAsync<T>(T folderId)
{
var folderDao = DaoFactory.GetFolderDao<T>();
return await GetBreadCrumbsAsync(folderId, folderDao);
return GetBreadCrumbsAsync(folderId, folderDao);
}
public List<FileEntry> GetBreadCrumbs<T>(T folderId, IFolderDao<T> folderDao)
@ -1372,9 +1372,9 @@ namespace ASC.Web.Files.Utils
return BreadCrumbsManager.GetBreadCrumbs(folderId);
}
public async Task<List<FileEntry>> GetBreadCrumbsAsync<T>(T folderId)
public Task<List<FileEntry>> GetBreadCrumbsAsync<T>(T folderId)
{
return await BreadCrumbsManager.GetBreadCrumbsAsync(folderId);
return BreadCrumbsManager.GetBreadCrumbsAsync(folderId);
}
public List<FileEntry> GetBreadCrumbs<T>(T folderId, IFolderDao<T> folderDao)
@ -1382,9 +1382,9 @@ namespace ASC.Web.Files.Utils
return BreadCrumbsManager.GetBreadCrumbs(folderId, folderDao);
}
public async Task<List<FileEntry>> GetBreadCrumbsAsync<T>(T folderId, IFolderDao<T> folderDao)
public Task<List<FileEntry>> GetBreadCrumbsAsync<T>(T folderId, IFolderDao<T> folderDao)
{
return await BreadCrumbsManager.GetBreadCrumbsAsync(folderId, folderDao);
return BreadCrumbsManager.GetBreadCrumbsAsync(folderId, folderDao);
}
public void CheckFolderId<T>(IFolderDao<T> folderDao, IEnumerable<FileEntry<T>> entries)
@ -1426,9 +1426,9 @@ namespace ASC.Web.Files.Utils
return LockerManager.FileLockedForMe(fileId, userId);
}
public async Task<bool> FileLockedForMeAsync<T>(T fileId, Guid userId = default)
public Task<bool> FileLockedForMeAsync<T>(T fileId, Guid userId = default)
{
return await LockerManager.FileLockedForMeAsync(fileId, userId);
return LockerManager.FileLockedForMeAsync(fileId, userId);
}
public Guid FileLockedBy<T>(T fileId, ITagDao<T> tagDao)
@ -1701,7 +1701,7 @@ namespace ASC.Web.Files.Utils
request.RequestUri = new Uri(downloadUri);
using var httpClient = new HttpClient();
using var response = httpClient.Send(request);
using var response = await httpClient.SendAsync(request);
using var editedFileStream = new ResponseStream(response);
await editedFileStream.CopyToAsync(tmpStream);
}
@ -2063,7 +2063,7 @@ namespace ASC.Web.Files.Utils
lastVersionFile = await UpdateToVersionFileAsync(fileVersion.ID, fileVersion.Version, null, checkRight);
}
fileDao.CompleteVersionAsync(fileVersion.ID, fileVersion.Version).Wait();
await fileDao.CompleteVersionAsync(fileVersion.ID, fileVersion.Version);
lastVersionFile.VersionGroup++;
}
}

4
products/ASC.Files/Core/Utils/FileConverter.cs
View File

@ -664,9 +664,9 @@ namespace ASC.Web.Files.Utils
return Exec(file, FileUtility.GetInternalExtension(file.Title));
}
public async Task<Stream> ExecAsync<T>(File<T> file)
public Task<Stream> ExecAsync<T>(File<T> file)
{
return await ExecAsync(file, FileUtility.GetInternalExtension(file.Title));
return ExecAsync(file, FileUtility.GetInternalExtension(file.Title));
}
public Stream Exec<T>(File<T> file, string toExtension)

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

@ -355,7 +355,7 @@ namespace ASC.Web.Files.Utils
if (fileEntry.RootFolderType == FolderType.BUNCH && !userIDs.Any())
{
var folderDao = DaoFactory.GetFolderDao<T>();
var path = folderDao.GetBunchObjectIDAsync(fileEntry.RootFolderId).Result;
var path = await folderDao.GetBunchObjectIDAsync(fileEntry.RootFolderId);
var projectID = path.Split('/').Last();
if (string.IsNullOrEmpty(projectID)) return;
@ -523,8 +523,8 @@ namespace ASC.Web.Files.Utils
T folderID;
int valueNew;
var userFolderId = internalFolderDao.GetFolderIDUserAsync(false, userID).Result;
var privacyFolderId = internalFolderDao.GetFolderIDPrivacyAsync(false, userID).Result;
var userFolderId = await internalFolderDao.GetFolderIDUserAsync(false, userID);
var privacyFolderId = await internalFolderDao.GetFolderIDPrivacyAsync(false, userID);
var removeTags = new List<Tag>();
@ -1174,16 +1174,16 @@ namespace ASC.Web.Files.Utils
{
await RemoveMarkAsNewAsync(parent);
}
}
}
await SetTagsNew(entries.OfType<FileEntry<int>>().ToList());
await SetTagsNew(entries.OfType<FileEntry<string>>().ToList());
}
async Task SetTagsNew<T1>(List<FileEntry<T1>> fileEntries)
{
var tags = await totalTags.ToListAsync();
SetTagsNew(tags, entries.OfType<FileEntry<int>>().ToList());
SetTagsNew(tags, entries.OfType<FileEntry<string>>().ToList());
}
void SetTagsNew<T1>(List<Tag> tags, List<FileEntry<T1>> fileEntries)
{
fileEntries
.ForEach(
entry =>

4
products/ASC.Files/Core/Utils/FileSharing.cs
View File

@ -318,11 +318,11 @@ namespace ASC.Web.Files.Utils
});
}
public async Task RemoveAceAsync(IAsyncEnumerable<FileEntry<T>> entries)
public Task RemoveAceAsync(IAsyncEnumerable<FileEntry<T>> entries)
{
var fileSecurity = FileSecurity;
await entries.ForEachAwaitAsync(
return entries.ForEachAwaitAsync(
async entry =>
{
if (entry.RootFolderType != FolderType.USER && entry.RootFolderType != FolderType.Privacy

4
products/ASC.Files/Core/Utils/FileUploader.cs
View File

@ -120,9 +120,9 @@ namespace ASC.Web.Files.Utils
return Exec(folderId, title, contentLength, data, !FilesSettingsHelper.UpdateIfExist);
}
public async Task<File<T>> ExecAsync<T>(T folderId, string title, long contentLength, Stream data)
public Task<File<T>> ExecAsync<T>(T folderId, string title, long contentLength, Stream data)
{
return await ExecAsync(folderId, title, contentLength, data, !FilesSettingsHelper.UpdateIfExist);
return ExecAsync(folderId, title, contentLength, data, !FilesSettingsHelper.UpdateIfExist);
}
public File<T> Exec<T>(T folderId, string title, long contentLength, Stream data, bool createNewIfExist, bool deleteConvertStatus = true)

404
products/ASC.Files/Server/Controllers/FilesController.cs
View File

@ -229,10 +229,10 @@ namespace ASC.Api.Documents
}
[Read("@privacy")]
public async Task<FolderContentWrapper<int>> GetPrivacyFolderAsync(Guid userIdOrGroupId, FilterType filterType, bool withsubfolders)
public Task<FolderContentWrapper<int>> GetPrivacyFolderAsync(Guid userIdOrGroupId, FilterType filterType, bool withsubfolders)
{
if (!IsAvailablePrivacyRoomSettings()) throw new System.Security.SecurityException();
return await FilesControllerHelperInt.GetFolderAsync(GlobalFolderHelper.FolderPrivacy, userIdOrGroupId, filterType, withsubfolders);
return FilesControllerHelperInt.GetFolderAsync(GlobalFolderHelper.FolderPrivacy, userIdOrGroupId, filterType, withsubfolders);
}
[Read("@privacy/available")]
@ -250,9 +250,9 @@ namespace ASC.Api.Documents
/// <category>Folders</category>
/// <returns>My folder contents</returns>
[Read("@my")]
public async Task<FolderContentWrapper<int>> GetMyFolderAsync(Guid userIdOrGroupId, FilterType filterType, bool withsubfolders)
public Task<FolderContentWrapper<int>> GetMyFolderAsync(Guid userIdOrGroupId, FilterType filterType, bool withsubfolders)
{
return await FilesControllerHelperInt.GetFolderAsync(GlobalFolderHelper.FolderMy, userIdOrGroupId, filterType, withsubfolders);
return FilesControllerHelperInt.GetFolderAsync(GlobalFolderHelper.FolderMy, userIdOrGroupId, filterType, withsubfolders);
}
/// <summary>
@ -264,9 +264,9 @@ namespace ASC.Api.Documents
/// <category>Folders</category>
/// <returns>Projects folder contents</returns>
[Read("@projects")]
public async Task<FolderContentWrapper<string>> GetProjectsFolderAsync(Guid userIdOrGroupId, FilterType filterType, bool withsubfolders)
public Task<FolderContentWrapper<string>> GetProjectsFolderAsync(Guid userIdOrGroupId, FilterType filterType, bool withsubfolders)
{
return await FilesControllerHelperString.GetFolderAsync(GlobalFolderHelper.GetFolderProjects<string>(), userIdOrGroupId, filterType, withsubfolders);
return FilesControllerHelperString.GetFolderAsync(GlobalFolderHelper.GetFolderProjects<string>(), userIdOrGroupId, filterType, withsubfolders);
}
@ -279,9 +279,9 @@ namespace ASC.Api.Documents
/// <category>Folders</category>
/// <returns>Common folder contents</returns>
[Read("@common")]
public async Task<FolderContentWrapper<int>> GetCommonFolderAsync(Guid userIdOrGroupId, FilterType filterType, bool withsubfolders)
public Task<FolderContentWrapper<int>> GetCommonFolderAsync(Guid userIdOrGroupId, FilterType filterType, bool withsubfolders)
{
return await FilesControllerHelperInt.GetFolderAsync(GlobalFolderHelper.FolderCommon, userIdOrGroupId, filterType, withsubfolders);
return FilesControllerHelperInt.GetFolderAsync(GlobalFolderHelper.FolderCommon, userIdOrGroupId, filterType, withsubfolders);
}
/// <summary>
@ -293,9 +293,9 @@ namespace ASC.Api.Documents
/// <category>Folders</category>
/// <returns>Shared folder contents</returns>
[Read("@share")]
public async Task<FolderContentWrapper<int>> GetShareFolderAsync(Guid userIdOrGroupId, FilterType filterType, bool withsubfolders)
public Task<FolderContentWrapper<int>> GetShareFolderAsync(Guid userIdOrGroupId, FilterType filterType, bool withsubfolders)
{
return await FilesControllerHelperInt.GetFolderAsync(GlobalFolderHelper.FolderShare, userIdOrGroupId, filterType, withsubfolders);
return FilesControllerHelperInt.GetFolderAsync(GlobalFolderHelper.FolderShare, userIdOrGroupId, filterType, withsubfolders);
}
/// <summary>
@ -305,21 +305,21 @@ namespace ASC.Api.Documents
/// <category>Folders</category>
/// <returns>Recent contents</returns>
[Read("@recent")]
public async Task<FolderContentWrapper<int>> GetRecentFolderAsync(Guid userIdOrGroupId, FilterType filterType, bool withsubfolders)
public Task<FolderContentWrapper<int>> GetRecentFolderAsync(Guid userIdOrGroupId, FilterType filterType, bool withsubfolders)
{
return await FilesControllerHelperInt.GetFolderAsync(GlobalFolderHelper.FolderRecent, userIdOrGroupId, filterType, withsubfolders);
return FilesControllerHelperInt.GetFolderAsync(GlobalFolderHelper.FolderRecent, userIdOrGroupId, filterType, withsubfolders);
}
[Create("file/{fileId}/recent", order: int.MaxValue)]
public async Task<FileWrapper<string>> AddToRecentAsync(string fileId)
public Task<FileWrapper<string>> AddToRecentAsync(string fileId)
{
return await FilesControllerHelperString.AddToRecentAsync(fileId);
return FilesControllerHelperString.AddToRecentAsync(fileId);
}
[Create("file/{fileId:int}/recent", order: int.MaxValue - 1)]
public async Task<FileWrapper<int>> AddToRecentAsync(int fileId)
public Task<FileWrapper<int>> AddToRecentAsync(int fileId)
{
return await FilesControllerHelperInt.AddToRecentAsync(fileId);
return FilesControllerHelperInt.AddToRecentAsync(fileId);
}
/// <summary>
@ -329,9 +329,9 @@ namespace ASC.Api.Documents
/// <category>Folders</category>
/// <returns>Favorites contents</returns>
[Read("@favorites")]
public async Task<FolderContentWrapper<int>> GetFavoritesFolderAsync(Guid userIdOrGroupId, FilterType filterType, bool withsubfolders)
public Task<FolderContentWrapper<int>> GetFavoritesFolderAsync(Guid userIdOrGroupId, FilterType filterType, bool withsubfolders)
{
return await FilesControllerHelperInt.GetFolderAsync(GlobalFolderHelper.FolderFavorites, userIdOrGroupId, filterType, withsubfolders);
return FilesControllerHelperInt.GetFolderAsync(GlobalFolderHelper.FolderFavorites, userIdOrGroupId, filterType, withsubfolders);
}
/// <summary>
@ -341,9 +341,9 @@ namespace ASC.Api.Documents
/// <category>Folders</category>
/// <returns>Templates contents</returns>
[Read("@templates")]
public async Task<FolderContentWrapper<int>> GetTemplatesFolderAsync(Guid userIdOrGroupId, FilterType filterType, bool withsubfolders)
public Task<FolderContentWrapper<int>> GetTemplatesFolderAsync(Guid userIdOrGroupId, FilterType filterType, bool withsubfolders)
{
return await FilesControllerHelperInt.GetFolderAsync(GlobalFolderHelper.FolderTemplates, userIdOrGroupId, filterType, withsubfolders);
return FilesControllerHelperInt.GetFolderAsync(GlobalFolderHelper.FolderTemplates, userIdOrGroupId, filterType, withsubfolders);
}
/// <summary>
@ -355,9 +355,9 @@ namespace ASC.Api.Documents
/// <category>Folders</category>
/// <returns>Trash folder contents</returns>
[Read("@trash")]
public async Task<FolderContentWrapper<int>> GetTrashFolderAsync(Guid userIdOrGroupId, FilterType filterType, bool withsubfolders)
public Task<FolderContentWrapper<int>> GetTrashFolderAsync(Guid userIdOrGroupId, FilterType filterType, bool withsubfolders)
{
return await FilesControllerHelperInt.GetFolderAsync(Convert.ToInt32(GlobalFolderHelper.FolderTrash), userIdOrGroupId, filterType, withsubfolders);
return FilesControllerHelperInt.GetFolderAsync(Convert.ToInt32(GlobalFolderHelper.FolderTrash), userIdOrGroupId, filterType, withsubfolders);
}
/// <summary>
@ -379,9 +379,9 @@ namespace ASC.Api.Documents
}
[Read("{folderId:int}", order: int.MaxValue - 1, DisableFormat = true)]
public async Task<FolderContentWrapper<int>> GetFolderAsync(int folderId, Guid userIdOrGroupId, FilterType filterType, bool withsubfolders)
public Task<FolderContentWrapper<int>> GetFolderAsync(int folderId, Guid userIdOrGroupId, FilterType filterType, bool withsubfolders)
{
return await FilesControllerHelperInt.GetFolderAsync(folderId, userIdOrGroupId, filterType, withsubfolders);
return FilesControllerHelperInt.GetFolderAsync(folderId, userIdOrGroupId, filterType, withsubfolders);
}
[Read("{folderId}/subfolders")]
@ -397,15 +397,15 @@ namespace ASC.Api.Documents
}
[Read("{folderId}/news")]
public async Task<List<FileEntryWrapper>> GetNewItemsAsync(string folderId)
public Task<List<FileEntryWrapper>> GetNewItemsAsync(string folderId)
{
return await FilesControllerHelperString.GetNewItemsAsync(folderId);
return FilesControllerHelperString.GetNewItemsAsync(folderId);
}
[Read("{folderId:int}/news")]
public async Task<List<FileEntryWrapper>> GetNewItemsAsync(int folderId)
public Task<List<FileEntryWrapper>> GetNewItemsAsync(int folderId)
{
return await FilesControllerHelperInt.GetNewItemsAsync(folderId);
return FilesControllerHelperInt.GetNewItemsAsync(folderId);
}
/// <summary>
@ -544,9 +544,9 @@ namespace ASC.Api.Documents
return await InsertFileAsync(folderId, model);
}
private async Task<FileWrapper<int>> InsertFileAsync(int folderId, InsertFileModel model)
private Task<FileWrapper<int>> InsertFileAsync(int folderId, InsertFileModel model)
{
return await FilesControllerHelperInt.InsertFileAsync(folderId, model.Stream, model.Title, model.CreateNewIfExist, model.KeepConvertStatus);
return FilesControllerHelperInt.InsertFileAsync(folderId, model.Stream, model.Title, model.CreateNewIfExist, model.KeepConvertStatus);
}
/// <summary>
@ -649,15 +649,15 @@ namespace ASC.Api.Documents
/// <category>Files</category>
/// <returns></returns>
[Read("file/{fileId}/trackeditfile")]
public async Task<KeyValuePair<bool, string>> TrackEditFileAsync(string fileId, Guid tabId, string docKeyForTrack, string doc, bool isFinish)
public Task<KeyValuePair<bool, string>> TrackEditFileAsync(string fileId, Guid tabId, string docKeyForTrack, string doc, bool isFinish)
{
return await FilesControllerHelperString.TrackEditFileAsync(fileId, tabId, docKeyForTrack, doc, isFinish);
return FilesControllerHelperString.TrackEditFileAsync(fileId, tabId, docKeyForTrack, doc, isFinish);
}
[Read("file/{fileId:int}/trackeditfile")]
public async Task<KeyValuePair<bool, string>> TrackEditFileAsync(int fileId, Guid tabId, string docKeyForTrack, string doc, bool isFinish)
public Task<KeyValuePair<bool, string>> TrackEditFileAsync(int fileId, Guid tabId, string docKeyForTrack, string doc, bool isFinish)
{
return await FilesControllerHelperInt.TrackEditFileAsync(fileId, tabId, docKeyForTrack, doc, isFinish);
return FilesControllerHelperInt.TrackEditFileAsync(fileId, tabId, docKeyForTrack, doc, isFinish);
}
/// <summary>
@ -670,16 +670,16 @@ namespace ASC.Api.Documents
/// <returns></returns>
[AllowAnonymous]
[Read("file/{fileId}/openedit", Check = false)]
public async Task<Configuration<string>> OpenEditAsync(string fileId, int version, string doc, bool view)
public Task<Configuration<string>> OpenEditAsync(string fileId, int version, string doc, bool view)
{
return await FilesControllerHelperString.OpenEditAsync(fileId, version, doc, view);
return FilesControllerHelperString.OpenEditAsync(fileId, version, doc, view);
}
[AllowAnonymous]
[Read("file/{fileId:int}/openedit", Check = false)]
public async Task<Configuration<int>> OpenEditAsync(int fileId, int version, string doc, bool view)
public Task<Configuration<int>> OpenEditAsync(int fileId, int version, string doc, bool view)
{
return await FilesControllerHelperInt.OpenEditAsync(fileId, version, doc, view);
return FilesControllerHelperInt.OpenEditAsync(fileId, version, doc, view);
}
@ -716,29 +716,29 @@ namespace ASC.Api.Documents
/// ]]>
/// </returns>
[Create("{folderId}/upload/create_session")]
public async Task<object> CreateUploadSessionFromBodyAsync(string folderId, [FromBody] SessionModel sessionModel)
public Task<object> CreateUploadSessionFromBodyAsync(string folderId, [FromBody] SessionModel sessionModel)
{
return await FilesControllerHelperString.CreateUploadSessionAsync(folderId, sessionModel.FileName, sessionModel.FileSize, sessionModel.RelativePath, sessionModel.Encrypted);
return FilesControllerHelperString.CreateUploadSessionAsync(folderId, sessionModel.FileName, sessionModel.FileSize, sessionModel.RelativePath, sessionModel.Encrypted);
}
[Create("{folderId}/upload/create_session")]
[Consumes("application/x-www-form-urlencoded")]
public async Task<object> CreateUploadSessionFromFormAsync(string folderId, [FromForm] SessionModel sessionModel)
public Task<object> CreateUploadSessionFromFormAsync(string folderId, [FromForm] SessionModel sessionModel)
{
return await FilesControllerHelperString.CreateUploadSessionAsync(folderId, sessionModel.FileName, sessionModel.FileSize, sessionModel.RelativePath, sessionModel.Encrypted);
return FilesControllerHelperString.CreateUploadSessionAsync(folderId, sessionModel.FileName, sessionModel.FileSize, sessionModel.RelativePath, sessionModel.Encrypted);
}
[Create("{folderId:int}/upload/create_session")]
public async Task<object> CreateUploadSessionFromBodyAsync(int folderId, [FromBody] SessionModel sessionModel)
public Task<object> CreateUploadSessionFromBodyAsync(int folderId, [FromBody] SessionModel sessionModel)
{
return await FilesControllerHelperInt.CreateUploadSessionAsync(folderId, sessionModel.FileName, sessionModel.FileSize, sessionModel.RelativePath, sessionModel.Encrypted);
return FilesControllerHelperInt.CreateUploadSessionAsync(folderId, sessionModel.FileName, sessionModel.FileSize, sessionModel.RelativePath, sessionModel.Encrypted);
}
[Create("{folderId:int}/upload/create_session")]
[Consumes("application/x-www-form-urlencoded")]
public async Task<object> CreateUploadSessionFromFormAsync(int folderId, [FromForm] SessionModel sessionModel)
public Task<object> CreateUploadSessionFromFormAsync(int folderId, [FromForm] SessionModel sessionModel)
{
return await FilesControllerHelperInt.CreateUploadSessionAsync(folderId, sessionModel.FileName, sessionModel.FileSize, sessionModel.RelativePath, sessionModel.Encrypted);
return FilesControllerHelperInt.CreateUploadSessionAsync(folderId, sessionModel.FileName, sessionModel.FileSize, sessionModel.RelativePath, sessionModel.Encrypted);
}
/// <summary>
@ -750,16 +750,16 @@ namespace ASC.Api.Documents
/// <param name="content">File contents</param>
/// <returns>Folder contents</returns>
[Create("@my/text")]
public async Task<FileWrapper<int>> CreateTextFileInMyFromBodyAsync([FromBody] CreateTextOrHtmlFileModel model)
public Task<FileWrapper<int>> CreateTextFileInMyFromBodyAsync([FromBody] CreateTextOrHtmlFileModel model)
{
return await CreateTextFileAsync(GlobalFolderHelper.FolderMy, model);
return CreateTextFileAsync(GlobalFolderHelper.FolderMy, model);
}
[Create("@my/text")]
[Consumes("application/x-www-form-urlencoded")]
public async Task<FileWrapper<int>> CreateTextFileInMyFromFormAsync([FromForm] CreateTextOrHtmlFileModel model)
public Task<FileWrapper<int>> CreateTextFileInMyFromFormAsync([FromForm] CreateTextOrHtmlFileModel model)
{
return await CreateTextFileAsync(GlobalFolderHelper.FolderMy, model);
return CreateTextFileAsync(GlobalFolderHelper.FolderMy, model);
}
/// <summary>
@ -771,16 +771,16 @@ namespace ASC.Api.Documents
/// <param name="content">File contents</param>
/// <returns>Folder contents</returns>
[Create("@common/text")]
public async Task<FileWrapper<int>> CreateTextFileInCommonFromBodyAsync([FromBody] CreateTextOrHtmlFileModel model)
public Task<FileWrapper<int>> CreateTextFileInCommonFromBodyAsync([FromBody] CreateTextOrHtmlFileModel model)
{
return await CreateTextFileAsync(GlobalFolderHelper.FolderCommon, model);
return CreateTextFileAsync(GlobalFolderHelper.FolderCommon, model);
}
[Create("@common/text")]
[Consumes("application/x-www-form-urlencoded")]
public async Task<FileWrapper<int>> CreateTextFileInCommonFromFormAsync([FromForm] CreateTextOrHtmlFileModel model)
public Task<FileWrapper<int>> CreateTextFileInCommonFromFormAsync([FromForm] CreateTextOrHtmlFileModel model)
{
return await CreateTextFileAsync(GlobalFolderHelper.FolderCommon, model);
return CreateTextFileAsync(GlobalFolderHelper.FolderCommon, model);
}
/// <summary>
@ -793,39 +793,39 @@ namespace ASC.Api.Documents
/// <param name="content">File contents</param>
/// <returns>Folder contents</returns>
[Create("{folderId}/text")]
public async Task<FileWrapper<string>> CreateTextFileFromBodyAsync(string folderId, [FromBody] CreateTextOrHtmlFileModel model)
public Task<FileWrapper<string>> CreateTextFileFromBodyAsync(string folderId, [FromBody] CreateTextOrHtmlFileModel model)
{
return await CreateTextFileAsync(folderId, model);
return CreateTextFileAsync(folderId, model);
}
[Create("{folderId}/text")]
[Consumes("application/x-www-form-urlencoded")]
public async Task<FileWrapper<string>> CreateTextFileFromFormAsync(string folderId, [FromForm] CreateTextOrHtmlFileModel model)
public Task<FileWrapper<string>> CreateTextFileFromFormAsync(string folderId, [FromForm] CreateTextOrHtmlFileModel model)
{
return await CreateTextFileAsync(folderId, model);
return CreateTextFileAsync(folderId, model);
}
private async Task<FileWrapper<string>> CreateTextFileAsync(string folderId, CreateTextOrHtmlFileModel model)
private Task<FileWrapper<string>> CreateTextFileAsync(string folderId, CreateTextOrHtmlFileModel model)
{
return await FilesControllerHelperString.CreateTextFileAsync(folderId, model.Title, model.Content);
return FilesControllerHelperString.CreateTextFileAsync(folderId, model.Title, model.Content);
}
[Create("{folderId:int}/text")]
public async Task<FileWrapper<int>> CreateTextFileFromBodyAsync(int folderId, [FromBody] CreateTextOrHtmlFileModel model)
public Task<FileWrapper<int>> CreateTextFileFromBodyAsync(int folderId, [FromBody] CreateTextOrHtmlFileModel model)
{
return await CreateTextFileAsync(folderId, model);
return CreateTextFileAsync(folderId, model);
}
[Create("{folderId:int}/text")]
[Consumes("application/x-www-form-urlencoded")]
public async Task<FileWrapper<int>> CreateTextFileFromFormAsync(int folderId, [FromForm] CreateTextOrHtmlFileModel model)
public Task<FileWrapper<int>> CreateTextFileFromFormAsync(int folderId, [FromForm] CreateTextOrHtmlFileModel model)
{
return await CreateTextFileAsync(folderId, model);
return CreateTextFileAsync(folderId, model);
}
private async Task<FileWrapper<int>> CreateTextFileAsync(int folderId, CreateTextOrHtmlFileModel model)
private Task<FileWrapper<int>> CreateTextFileAsync(int folderId, CreateTextOrHtmlFileModel model)
{
return await FilesControllerHelperInt.CreateTextFileAsync(folderId, model.Title, model.Content);
return FilesControllerHelperInt.CreateTextFileAsync(folderId, model.Title, model.Content);
}
/// <summary>
@ -838,39 +838,39 @@ namespace ASC.Api.Documents
/// <param name="content">File contents</param>
/// <returns>Folder contents</returns>
[Create("{folderId}/html")]
public async Task<FileWrapper<string>> CreateHtmlFileFromBodyAsync(string folderId, [FromBody] CreateTextOrHtmlFileModel model)
public Task<FileWrapper<string>> CreateHtmlFileFromBodyAsync(string folderId, [FromBody] CreateTextOrHtmlFileModel model)
{
return await CreateHtmlFileAsync(folderId, model);
return CreateHtmlFileAsync(folderId, model);
}
[Create("{folderId}/html")]
[Consumes("application/x-www-form-urlencoded")]
public async Task<FileWrapper<string>> CreateHtmlFileFromFormAsync(string folderId, [FromForm] CreateTextOrHtmlFileModel model)
public Task<FileWrapper<string>> CreateHtmlFileFromFormAsync(string folderId, [FromForm] CreateTextOrHtmlFileModel model)
{
return await CreateHtmlFileAsync(folderId, model);
return CreateHtmlFileAsync(folderId, model);
}
private async Task<FileWrapper<string>> CreateHtmlFileAsync(string folderId, CreateTextOrHtmlFileModel model)
private Task<FileWrapper<string>> CreateHtmlFileAsync(string folderId, CreateTextOrHtmlFileModel model)
{
return await FilesControllerHelperString.CreateHtmlFileAsync(folderId, model.Title, model.Content);
return FilesControllerHelperString.CreateHtmlFileAsync(folderId, model.Title, model.Content);
}
[Create("{folderId:int}/html")]
public async Task<FileWrapper<int>> CreateHtmlFileFromBodyAsync(int folderId, [FromBody] CreateTextOrHtmlFileModel model)
public Task<FileWrapper<int>> CreateHtmlFileFromBodyAsync(int folderId, [FromBody] CreateTextOrHtmlFileModel model)
{
return await CreateHtmlFileAsync(folderId, model);
return CreateHtmlFileAsync(folderId, model);
}
[Create("{folderId:int}/html")]
[Consumes("application/x-www-form-urlencoded")]
public async Task<FileWrapper<int>> CreateHtmlFileFromFormAsync(int folderId, [FromForm] CreateTextOrHtmlFileModel model)
public Task<FileWrapper<int>> CreateHtmlFileFromFormAsync(int folderId, [FromForm] CreateTextOrHtmlFileModel model)
{
return await CreateHtmlFileAsync(folderId, model);
return CreateHtmlFileAsync(folderId, model);
}
private async Task<FileWrapper<int>> CreateHtmlFileAsync(int folderId, CreateTextOrHtmlFileModel model)
private Task<FileWrapper<int>> CreateHtmlFileAsync(int folderId, CreateTextOrHtmlFileModel model)
{
return await FilesControllerHelperInt.CreateHtmlFileAsync(folderId, model.Title, model.Content);
return FilesControllerHelperInt.CreateHtmlFileAsync(folderId, model.Title, model.Content);
}
/// <summary>
@ -882,16 +882,16 @@ namespace ASC.Api.Documents
/// <param name="content">File contents</param>
/// <returns>Folder contents</returns>
[Create("@my/html")]
public async Task<FileWrapper<int>> CreateHtmlFileInMyFromBodyAsync([FromBody] CreateTextOrHtmlFileModel model)
public Task<FileWrapper<int>> CreateHtmlFileInMyFromBodyAsync([FromBody] CreateTextOrHtmlFileModel model)
{
return await CreateHtmlFileAsync(GlobalFolderHelper.FolderMy, model);
return CreateHtmlFileAsync(GlobalFolderHelper.FolderMy, model);
}
[Create("@my/html")]
[Consumes("application/x-www-form-urlencoded")]
public async Task<FileWrapper<int>> CreateHtmlFileInMyFromFormAsync([FromForm] CreateTextOrHtmlFileModel model)
public Task<FileWrapper<int>> CreateHtmlFileInMyFromFormAsync([FromForm] CreateTextOrHtmlFileModel model)
{
return await CreateHtmlFileAsync(GlobalFolderHelper.FolderMy, model);
return CreateHtmlFileAsync(GlobalFolderHelper.FolderMy, model);
}
/// <summary>
@ -903,16 +903,16 @@ namespace ASC.Api.Documents
/// <param name="content">File contents</param>
/// <returns>Folder contents</returns>
[Create("@common/html")]
public async Task<FileWrapper<int>> CreateHtmlFileInCommonFromBodyAsync([FromBody] CreateTextOrHtmlFileModel model)
public Task<FileWrapper<int>> CreateHtmlFileInCommonFromBodyAsync([FromBody] CreateTextOrHtmlFileModel model)
{
return await CreateHtmlFileAsync(GlobalFolderHelper.FolderCommon, model);
return CreateHtmlFileAsync(GlobalFolderHelper.FolderCommon, model);
}
[Create("@common/html")]
[Consumes("application/x-www-form-urlencoded")]
public async Task<FileWrapper<int>> CreateHtmlFileInCommonFromFormAsync([FromForm] CreateTextOrHtmlFileModel model)
public Task<FileWrapper<int>> CreateHtmlFileInCommonFromFormAsync([FromForm] CreateTextOrHtmlFileModel model)
{
return await CreateHtmlFileAsync(GlobalFolderHelper.FolderCommon, model);
return CreateHtmlFileAsync(GlobalFolderHelper.FolderCommon, model);
}
/// <summary>
@ -926,29 +926,29 @@ namespace ASC.Api.Documents
/// <param name="title">Title of new folder</param>
/// <returns>New folder contents</returns>
[Create("folder/{folderId}", order: int.MaxValue, DisableFormat = true)]
public async Task<FolderWrapper<string>> CreateFolderFromBodyAsync(string folderId, [FromBody] CreateFolderModel folderModel)
public Task<FolderWrapper<string>> CreateFolderFromBodyAsync(string folderId, [FromBody] CreateFolderModel folderModel)
{
return await FilesControllerHelperString.CreateFolderAsync(folderId, folderModel.Title);
return FilesControllerHelperString.CreateFolderAsync(folderId, folderModel.Title);
}
[Create("folder/{folderId}", order: int.MaxValue, DisableFormat = true)]
[Consumes("application/x-www-form-urlencoded")]
public async Task<FolderWrapper<string>> CreateFolderFromFormAsync(string folderId, [FromForm] CreateFolderModel folderModel)
public Task<FolderWrapper<string>> CreateFolderFromFormAsync(string folderId, [FromForm] CreateFolderModel folderModel)
{
return await FilesControllerHelperString.CreateFolderAsync(folderId, folderModel.Title);
return FilesControllerHelperString.CreateFolderAsync(folderId, folderModel.Title);
}
[Create("folder/{folderId:int}", order: int.MaxValue - 1, DisableFormat = true)]
public async Task<FolderWrapper<int>> CreateFolderFromBodyAsync(int folderId, [FromBody] CreateFolderModel folderModel)
public Task<FolderWrapper<int>> CreateFolderFromBodyAsync(int folderId, [FromBody] CreateFolderModel folderModel)
{
return await FilesControllerHelperInt.CreateFolderAsync(folderId, folderModel.Title);
return FilesControllerHelperInt.CreateFolderAsync(folderId, folderModel.Title);
}
[Create("folder/{folderId:int}", order: int.MaxValue - 1, DisableFormat = true)]
[Consumes("application/x-www-form-urlencoded")]
public async Task<FolderWrapper<int>> CreateFolderFromFormAsync(int folderId, [FromForm] CreateFolderModel folderModel)
public Task<FolderWrapper<int>> CreateFolderFromFormAsync(int folderId, [FromForm] CreateFolderModel folderModel)
{
return await FilesControllerHelperInt.CreateFolderAsync(folderId, folderModel.Title);
return FilesControllerHelperInt.CreateFolderAsync(folderId, folderModel.Title);
}
/// <summary>
@ -961,16 +961,16 @@ namespace ASC.Api.Documents
/// <returns>New file info</returns>
[Create("@my/file")]
public async Task<FileWrapper<int>> CreateFileFromBodyAsync([FromBody] CreateFileModel<int> model)
public Task<FileWrapper<int>> CreateFileFromBodyAsync([FromBody] CreateFileModel<int> model)
{
return await FilesControllerHelperInt.CreateFileAsync(GlobalFolderHelper.FolderMy, model.Title, model.TemplateId, model.EnableExternalExt);
return FilesControllerHelperInt.CreateFileAsync(GlobalFolderHelper.FolderMy, model.Title, model.TemplateId, model.EnableExternalExt);
}
[Create("@my/file")]
[Consumes("application/x-www-form-urlencoded")]
public async Task<FileWrapper<int>> CreateFileFromFormAsync([FromForm] CreateFileModel<int> model)
public Task<FileWrapper<int>> CreateFileFromFormAsync([FromForm] CreateFileModel<int> model)
{
return await FilesControllerHelperInt.CreateFileAsync(GlobalFolderHelper.FolderMy, model.Title, model.TemplateId, model.EnableExternalExt);
return FilesControllerHelperInt.CreateFileAsync(GlobalFolderHelper.FolderMy, model.Title, model.TemplateId, model.EnableExternalExt);
}
/// <summary>
@ -983,29 +983,29 @@ namespace ASC.Api.Documents
/// <remarks>In case the extension for the file title differs from DOCX/XLSX/PPTX and belongs to one of the known text, spreadsheet or presentation formats, it will be changed to DOCX/XLSX/PPTX accordingly. If the file extension is not set or is unknown, the DOCX extension will be added to the file title.</remarks>
/// <returns>New file info</returns>
[Create("{folderId}/file")]
public async Task<FileWrapper<string>> CreateFileFromBodyAsync(string folderId, [FromBody] CreateFileModel<string> model)
public Task<FileWrapper<string>> CreateFileFromBodyAsync(string folderId, [FromBody] CreateFileModel<string> model)
{
return await FilesControllerHelperString.CreateFileAsync(folderId, model.Title, model.TemplateId, model.EnableExternalExt);
return FilesControllerHelperString.CreateFileAsync(folderId, model.Title, model.TemplateId, model.EnableExternalExt);
}
[Create("{folderId}/file")]
[Consumes("application/x-www-form-urlencoded")]
public async Task<FileWrapper<string>> CreateFileFromFormAsync(string folderId, [FromForm] CreateFileModel<string> model)
public Task<FileWrapper<string>> CreateFileFromFormAsync(string folderId, [FromForm] CreateFileModel<string> model)
{
return await FilesControllerHelperString.CreateFileAsync(folderId, model.Title, model.TemplateId, model.EnableExternalExt);
return FilesControllerHelperString.CreateFileAsync(folderId, model.Title, model.TemplateId, model.EnableExternalExt);
}
[Create("{folderId:int}/file")]
public async Task<FileWrapper<int>> CreateFileFromBodyAsync(int folderId, [FromBody] CreateFileModel<int> model)
public Task<FileWrapper<int>> CreateFileFromBodyAsync(int folderId, [FromBody] CreateFileModel<int> model)
{
return await FilesControllerHelperInt.CreateFileAsync(folderId, model.Title, model.TemplateId, model.EnableExternalExt);
return FilesControllerHelperInt.CreateFileAsync(folderId, model.Title, model.TemplateId, model.EnableExternalExt);
}
[Create("{folderId:int}/file")]
[Consumes("application/x-www-form-urlencoded")]
public async Task<FileWrapper<int>> CreateFileFromFormAsync(int folderId, [FromForm] CreateFileModel<int> model)
public Task<FileWrapper<int>> CreateFileFromFormAsync(int folderId, [FromForm] CreateFileModel<int> model)
{
return await FilesControllerHelperInt.CreateFileAsync(folderId, model.Title, model.TemplateId, model.EnableExternalExt);
return FilesControllerHelperInt.CreateFileAsync(folderId, model.Title, model.TemplateId, model.EnableExternalExt);
}
/// <summary>
@ -1020,29 +1020,29 @@ namespace ASC.Api.Documents
/// <returns>Folder contents</returns>
[Update("folder/{folderId}", order: int.MaxValue, DisableFormat = true)]
public async Task<FolderWrapper<string>> RenameFolderFromBodyAsync(string folderId, [FromBody] CreateFolderModel folderModel)
public Task<FolderWrapper<string>> RenameFolderFromBodyAsync(string folderId, [FromBody] CreateFolderModel folderModel)
{
return await FilesControllerHelperString.RenameFolderAsync(folderId, folderModel.Title);
return FilesControllerHelperString.RenameFolderAsync(folderId, folderModel.Title);
}
[Update("folder/{folderId}", order: int.MaxValue, DisableFormat = true)]
[Consumes("application/x-www-form-urlencoded")]
public async Task<FolderWrapper<string>> RenameFolderFromFormAsync(string folderId, [FromForm] CreateFolderModel folderModel)
public Task<FolderWrapper<string>> RenameFolderFromFormAsync(string folderId, [FromForm] CreateFolderModel folderModel)
{
return await FilesControllerHelperString.RenameFolderAsync(folderId, folderModel.Title);
return FilesControllerHelperString.RenameFolderAsync(folderId, folderModel.Title);
}
[Update("folder/{folderId:int}", order: int.MaxValue - 1, DisableFormat = true)]
public async Task<FolderWrapper<int>> RenameFolderFromBodyAsync(int folderId, [FromBody] CreateFolderModel folderModel)
public Task<FolderWrapper<int>> RenameFolderFromBodyAsync(int folderId, [FromBody] CreateFolderModel folderModel)
{
return await FilesControllerHelperInt.RenameFolderAsync(folderId, folderModel.Title);
return FilesControllerHelperInt.RenameFolderAsync(folderId, folderModel.Title);
}
[Update("folder/{folderId:int}", order: int.MaxValue - 1, DisableFormat = true)]
[Consumes("application/x-www-form-urlencoded")]
public async Task<FolderWrapper<int>> RenameFolderFromFormAsync(int folderId, [FromForm] CreateFolderModel folderModel)
public Task<FolderWrapper<int>> RenameFolderFromFormAsync(int folderId, [FromForm] CreateFolderModel folderModel)
{
return await FilesControllerHelperInt.RenameFolderAsync(folderId, folderModel.Title);
return FilesControllerHelperInt.RenameFolderAsync(folderId, folderModel.Title);
}
[Create("owner")]
@ -1081,15 +1081,15 @@ namespace ASC.Api.Documents
/// <returns>Folder info</returns>
[Read("folder/{folderId}", order: int.MaxValue, DisableFormat = true)]
public async Task<FolderWrapper<string>> GetFolderInfoAsync(string folderId)
public Task<FolderWrapper<string>> GetFolderInfoAsync(string folderId)
{
return await FilesControllerHelperString.GetFolderInfoAsync(folderId);
return FilesControllerHelperString.GetFolderInfoAsync(folderId);
}
[Read("folder/{folderId:int}", order: int.MaxValue - 1, DisableFormat = true)]
public async Task<FolderWrapper<int>> GetFolderInfoAsync(int folderId)
public Task<FolderWrapper<int>> GetFolderInfoAsync(int folderId)
{
return await FilesControllerHelperInt.GetFolderInfoAsync(folderId);
return FilesControllerHelperInt.GetFolderInfoAsync(folderId);
}
/// <summary>
@ -1120,15 +1120,15 @@ namespace ASC.Api.Documents
/// <returns>File info</returns>
[Read("fileAsync/{fileId}", order: int.MaxValue, DisableFormat = true)]
public async Task<FileWrapper<string>> GetFileInfoAsync(string fileId, int version = -1)
public Task<FileWrapper<string>> GetFileInfoAsync(string fileId, int version = -1)
{
return await FilesControllerHelperString.GetFileInfoAsync(fileId, version);
return FilesControllerHelperString.GetFileInfoAsync(fileId, version);
}
[Read("fileAsync/{fileId:int}")]
public async Task<FileWrapper<int>> GetFileInfoAsync(int fileId, int version = -1)
public Task<FileWrapper<int>> GetFileInfoAsync(int fileId, int version = -1)
{
return await FilesControllerHelperInt.GetFileInfoAsync(fileId, version);
return FilesControllerHelperInt.GetFileInfoAsync(fileId, version);
}
/// <summary>
@ -1141,29 +1141,29 @@ namespace ASC.Api.Documents
/// <param name="lastVersion">File last version number</param>
/// <returns>File info</returns>
[Update("fileAsync/{fileId}", order: int.MaxValue, DisableFormat = true)]
public async Task<FileWrapper<string>> UpdateFileFromBodyAsync(string fileId, [FromBody] UpdateFileModel model)
public Task<FileWrapper<string>> UpdateFileFromBodyAsync(string fileId, [FromBody] UpdateFileModel model)
{
return await FilesControllerHelperString.UpdateFileAsync(fileId, model.Title, model.LastVersion);
return FilesControllerHelperString.UpdateFileAsync(fileId, model.Title, model.LastVersion);
}
[Update("fileAsync/{fileId}", order: int.MaxValue, DisableFormat = true)]
[Consumes("application/x-www-form-urlencoded")]
public async Task<FileWrapper<string>> UpdateFileFromFormAsync(string fileId, [FromForm] UpdateFileModel model)
public Task<FileWrapper<string>> UpdateFileFromFormAsync(string fileId, [FromForm] UpdateFileModel model)
{
return await FilesControllerHelperString.UpdateFileAsync(fileId, model.Title, model.LastVersion);
return FilesControllerHelperString.UpdateFileAsync(fileId, model.Title, model.LastVersion);
}
[Update("fileAsync/{fileId:int}", order: int.MaxValue - 1, DisableFormat = true)]
public async Task<FileWrapper<int>> UpdateFileFromBodyAsync(int fileId, [FromBody] UpdateFileModel model)
public Task<FileWrapper<int>> UpdateFileFromBodyAsync(int fileId, [FromBody] UpdateFileModel model)
{
return await FilesControllerHelperInt.UpdateFileAsync(fileId, model.Title, model.LastVersion);
return FilesControllerHelperInt.UpdateFileAsync(fileId, model.Title, model.LastVersion);
}
[Update("fileAsync/{fileId:int}", order: int.MaxValue - 1, DisableFormat = true)]
[Consumes("application/x-www-form-urlencoded")]
public async Task<FileWrapper<int>> UpdateFileFromFormAsync(int fileId, [FromForm] UpdateFileModel model)
public Task<FileWrapper<int>> UpdateFileFromFormAsync(int fileId, [FromForm] UpdateFileModel model)
{
return await FilesControllerHelperInt.UpdateFileAsync(fileId, model.Title, model.LastVersion);
return FilesControllerHelperInt.UpdateFileAsync(fileId, model.Title, model.LastVersion);
}
/// <summary>
@ -1423,27 +1423,27 @@ namespace ASC.Api.Documents
/// <param name="fileId">File ID</param>
/// <returns>File information</returns>
[Read("file/{fileId}/history")]
public async Task<IEnumerable<FileWrapper<string>>> GetFileVersionInfoAsync(string fileId)
public Task<IEnumerable<FileWrapper<string>>> GetFileVersionInfoAsync(string fileId)
{
return await FilesControllerHelperString.GetFileVersionInfoAsync(fileId);
return FilesControllerHelperString.GetFileVersionInfoAsync(fileId);
}
[Read("file/{fileId:int}/history")]
public async Task<IEnumerable<FileWrapper<int>>> GetFileVersionInfoAsync(int fileId)
public Task<IEnumerable<FileWrapper<int>>> GetFileVersionInfoAsync(int fileId)
{
return await FilesControllerHelperInt.GetFileVersionInfoAsync(fileId);
return FilesControllerHelperInt.GetFileVersionInfoAsync(fileId);
}
[Read("file/{fileId}/presigned")]
public async Task<DocumentService.FileLink> GetPresignedUriAsync(string fileId)
public Task<DocumentService.FileLink> GetPresignedUriAsync(string fileId)
{
return await FilesControllerHelperString.GetPresignedUriAsync(fileId);
return FilesControllerHelperString.GetPresignedUriAsync(fileId);
}
[Read("file/{fileId:int}/presigned")]
public async Task<DocumentService.FileLink> GetPresignedUriAsync(int fileId)
public Task<DocumentService.FileLink> GetPresignedUriAsync(int fileId)
{
return await FilesControllerHelperInt.GetPresignedUriAsync(fileId);
return FilesControllerHelperInt.GetPresignedUriAsync(fileId);
}
/// <summary>
@ -1456,55 +1456,55 @@ namespace ASC.Api.Documents
/// <returns></returns>
[Update("file/{fileId}/history")]
public async Task<IEnumerable<FileWrapper<string>>> ChangeHistoryFromBodyAsync(string fileId, [FromBody] ChangeHistoryModel model)
public Task<IEnumerable<FileWrapper<string>>> ChangeHistoryFromBodyAsync(string fileId, [FromBody] ChangeHistoryModel model)
{
return await FilesControllerHelperString.ChangeHistoryAsync(fileId, model.Version, model.ContinueVersion);
return FilesControllerHelperString.ChangeHistoryAsync(fileId, model.Version, model.ContinueVersion);
}
[Update("file/{fileId}/history")]
[Consumes("application/x-www-form-urlencoded")]
public async Task<IEnumerable<FileWrapper<string>>> ChangeHistoryFromFormAsync(string fileId, [FromForm] ChangeHistoryModel model)
public Task<IEnumerable<FileWrapper<string>>> ChangeHistoryFromFormAsync(string fileId, [FromForm] ChangeHistoryModel model)
{
return await FilesControllerHelperString.ChangeHistoryAsync(fileId, model.Version, model.ContinueVersion);
return FilesControllerHelperString.ChangeHistoryAsync(fileId, model.Version, model.ContinueVersion);
}
[Update("file/{fileId:int}/history")]
public async Task<IEnumerable<FileWrapper<int>>> ChangeHistoryFromBodyAsync(int fileId, [FromBody] ChangeHistoryModel model)
public Task<IEnumerable<FileWrapper<int>>> ChangeHistoryFromBodyAsync(int fileId, [FromBody] ChangeHistoryModel model)
{
return await FilesControllerHelperInt.ChangeHistoryAsync(fileId, model.Version, model.ContinueVersion);
return FilesControllerHelperInt.ChangeHistoryAsync(fileId, model.Version, model.ContinueVersion);
}
[Update("file/{fileId:int}/history")]
[Consumes("application/x-www-form-urlencoded")]
public async Task<IEnumerable<FileWrapper<int>>> ChangeHistoryFromFormAsync(int fileId, [FromForm] ChangeHistoryModel model)
public Task<IEnumerable<FileWrapper<int>>> ChangeHistoryFromFormAsync(int fileId, [FromForm] ChangeHistoryModel model)
{
return await FilesControllerHelperInt.ChangeHistoryAsync(fileId, model.Version, model.ContinueVersion);
return FilesControllerHelperInt.ChangeHistoryAsync(fileId, model.Version, model.ContinueVersion);
}
[Update("file/{fileId}/lock")]
public async Task<FileWrapper<string>> LockFileFromBodyAsync(string fileId, [FromBody] LockFileModel model)
public Task<FileWrapper<string>> LockFileFromBodyAsync(string fileId, [FromBody] LockFileModel model)
{
return await FilesControllerHelperString.LockFileAsync(fileId, model.LockFile);
return FilesControllerHelperString.LockFileAsync(fileId, model.LockFile);
}
[Update("file/{fileId}/lock")]
[Consumes("application/x-www-form-urlencoded")]
public async Task<FileWrapper<string>> LockFileFromFormAsync(string fileId, [FromForm] LockFileModel model)
public Task<FileWrapper<string>> LockFileFromFormAsync(string fileId, [FromForm] LockFileModel model)
{
return await FilesControllerHelperString.LockFileAsync(fileId, model.LockFile);
return FilesControllerHelperString.LockFileAsync(fileId, model.LockFile);
}
[Update("file/{fileId:int}/lock")]
public async Task<FileWrapper<int>> LockFileFromBodyAsync(int fileId, [FromBody] LockFileModel model)
public Task<FileWrapper<int>> LockFileFromBodyAsync(int fileId, [FromBody] LockFileModel model)
{
return await FilesControllerHelperInt.LockFileAsync(fileId, model.LockFile);
return FilesControllerHelperInt.LockFileAsync(fileId, model.LockFile);
}
[Update("file/{fileId:int}/lock")]
[Consumes("application/x-www-form-urlencoded")]
public async Task<FileWrapper<int>> LockFileFromFormAsync(int fileId, [FromForm] LockFileModel model)
public Task<FileWrapper<int>> LockFileFromFormAsync(int fileId, [FromForm] LockFileModel model)
{
return await FilesControllerHelperInt.LockFileAsync(fileId, model.LockFile);
return FilesControllerHelperInt.LockFileAsync(fileId, model.LockFile);
}
[Update("file/{fileId}/comment")]
@ -1542,15 +1542,15 @@ namespace ASC.Api.Documents
/// <returns>Shared file information</returns>
[Read("file/{fileId}/share")]
public async Task<IEnumerable<FileShareWrapper>> GetFileSecurityInfoAsync(string fileId)
public Task<IEnumerable<FileShareWrapper>> GetFileSecurityInfoAsync(string fileId)
{
return await FilesControllerHelperString.GetFileSecurityInfoAsync(fileId);
return FilesControllerHelperString.GetFileSecurityInfoAsync(fileId);
}
[Read("file/{fileId:int}/share")]
public async Task<IEnumerable<FileShareWrapper>> GetFileSecurityInfoAsync(int fileId)
public Task<IEnumerable<FileShareWrapper>> GetFileSecurityInfoAsync(int fileId)
{
return await FilesControllerHelperInt.GetFileSecurityInfoAsync(fileId);
return FilesControllerHelperInt.GetFileSecurityInfoAsync(fileId);
}
/// <summary>
@ -1562,15 +1562,15 @@ namespace ASC.Api.Documents
/// <returns>Shared folder information</returns>
[Read("folder/{folderId}/share")]
public async Task<IEnumerable<FileShareWrapper>> GetFolderSecurityInfoAsync(string folderId)
public Task<IEnumerable<FileShareWrapper>> GetFolderSecurityInfoAsync(string folderId)
{
return await FilesControllerHelperString.GetFolderSecurityInfoAsync(folderId);
return FilesControllerHelperString.GetFolderSecurityInfoAsync(folderId);
}
[Read("folder/{folderId:int}/share")]
public async Task<IEnumerable<FileShareWrapper>> GetFolderSecurityInfoAsync(int folderId)
public Task<IEnumerable<FileShareWrapper>> GetFolderSecurityInfoAsync(int folderId)
{
return await FilesControllerHelperInt.GetFolderSecurityInfoAsync(folderId);
return FilesControllerHelperInt.GetFolderSecurityInfoAsync(folderId);
}
[Create("share")]
@ -1613,42 +1613,42 @@ namespace ASC.Api.Documents
/// <returns>Shared file information</returns>
[Update("file/{fileId}/share")]
public async Task<IEnumerable<FileShareWrapper>> SetFileSecurityInfoFromBodyAsync(string fileId, [FromBody] SecurityInfoModel model)
public Task<IEnumerable<FileShareWrapper>> SetFileSecurityInfoFromBodyAsync(string fileId, [FromBody] SecurityInfoModel model)
{
return await FilesControllerHelperString.SetFileSecurityInfoAsync(fileId, model.Share, model.Notify, model.SharingMessage);
return FilesControllerHelperString.SetFileSecurityInfoAsync(fileId, model.Share, model.Notify, model.SharingMessage);
}
[Update("file/{fileId}/share")]
[Consumes("application/x-www-form-urlencoded")]
public async Task<IEnumerable<FileShareWrapper>> SetFileSecurityInfoFromFormAsync(string fileId, [FromForm] SecurityInfoModel model)
public Task<IEnumerable<FileShareWrapper>> SetFileSecurityInfoFromFormAsync(string fileId, [FromForm] SecurityInfoModel model)
{
return await FilesControllerHelperString.SetFileSecurityInfoAsync(fileId, model.Share, model.Notify, model.SharingMessage);
return FilesControllerHelperString.SetFileSecurityInfoAsync(fileId, model.Share, model.Notify, model.SharingMessage);
}
[Update("file/{fileId:int}/share")]
public async Task<IEnumerable<FileShareWrapper>> SetFileSecurityInfoFromBodyAsync(int fileId, [FromBody] SecurityInfoModel model)
public Task<IEnumerable<FileShareWrapper>> SetFileSecurityInfoFromBodyAsync(int fileId, [FromBody] SecurityInfoModel model)
{
return await FilesControllerHelperInt.SetFileSecurityInfoAsync(fileId, model.Share, model.Notify, model.SharingMessage);
return FilesControllerHelperInt.SetFileSecurityInfoAsync(fileId, model.Share, model.Notify, model.SharingMessage);
}
[Update("file/{fileId:int}/share")]
[Consumes("application/x-www-form-urlencoded")]
public async Task<IEnumerable<FileShareWrapper>> SetFileSecurityInfoFromFormAsync(int fileId, [FromForm] SecurityInfoModel model)
public Task<IEnumerable<FileShareWrapper>> SetFileSecurityInfoFromFormAsync(int fileId, [FromForm] SecurityInfoModel model)
{
return await FilesControllerHelperInt.SetFileSecurityInfoAsync(fileId, model.Share, model.Notify, model.SharingMessage);
return FilesControllerHelperInt.SetFileSecurityInfoAsync(fileId, model.Share, model.Notify, model.SharingMessage);
}
[Update("share")]
public async Task<IEnumerable<FileShareWrapper>> SetSecurityInfoFromBodyAsync([FromBody] SecurityInfoModel model)
public Task<IEnumerable<FileShareWrapper>> SetSecurityInfoFromBodyAsync([FromBody] SecurityInfoModel model)
{
return await SetSecurityInfoAsync(model);
return SetSecurityInfoAsync(model);
}
[Update("share")]
[Consumes("application/x-www-form-urlencoded")]
public async Task<IEnumerable<FileShareWrapper>> SetSecurityInfoFromFormAsync([FromForm] SecurityInfoModel model)
public Task<IEnumerable<FileShareWrapper>> SetSecurityInfoFromFormAsync([FromForm] SecurityInfoModel model)
{
return await SetSecurityInfoAsync(model);
return SetSecurityInfoAsync(model);
}
public async Task<IEnumerable<FileShareWrapper>> SetSecurityInfoAsync(SecurityInfoModel model)
@ -1677,29 +1677,29 @@ namespace ASC.Api.Documents
/// <returns>Shared folder information</returns>
[Update("folder/{folderId}/share")]
public async Task<IEnumerable<FileShareWrapper>> SetFolderSecurityInfoFromBodyAsync(string folderId, [FromBody] SecurityInfoModel model)
public Task<IEnumerable<FileShareWrapper>> SetFolderSecurityInfoFromBodyAsync(string folderId, [FromBody] SecurityInfoModel model)
{
return await FilesControllerHelperString.SetFolderSecurityInfoAsync(folderId, model.Share, model.Notify, model.SharingMessage);
return FilesControllerHelperString.SetFolderSecurityInfoAsync(folderId, model.Share, model.Notify, model.SharingMessage);
}
[Update("folder/{folderId}/share")]
[Consumes("application/x-www-form-urlencoded")]
public async Task<IEnumerable<FileShareWrapper>> SetFolderSecurityInfoFromFormAsync(string folderId, [FromForm] SecurityInfoModel model)
public Task<IEnumerable<FileShareWrapper>> SetFolderSecurityInfoFromFormAsync(string folderId, [FromForm] SecurityInfoModel model)
{
return await FilesControllerHelperString.SetFolderSecurityInfoAsync(folderId, model.Share, model.Notify, model.SharingMessage);
return FilesControllerHelperString.SetFolderSecurityInfoAsync(folderId, model.Share, model.Notify, model.SharingMessage);
}
[Update("folder/{folderId:int}/share")]
public async Task<IEnumerable<FileShareWrapper>> SetFolderSecurityInfoFromBodyAsync(int folderId, [FromBody] SecurityInfoModel model)
public Task<IEnumerable<FileShareWrapper>> SetFolderSecurityInfoFromBodyAsync(int folderId, [FromBody] SecurityInfoModel model)
{
return await FilesControllerHelperInt.SetFolderSecurityInfoAsync(folderId, model.Share, model.Notify, model.SharingMessage);
return FilesControllerHelperInt.SetFolderSecurityInfoAsync(folderId, model.Share, model.Notify, model.SharingMessage);
}
[Update("folder/{folderId:int}/share")]
[Consumes("application/x-www-form-urlencoded")]
public async Task<IEnumerable<FileShareWrapper>> SetFolderSecurityInfoFromFormAsync(int folderId, [FromForm] SecurityInfoModel model)
public Task<IEnumerable<FileShareWrapper>> SetFolderSecurityInfoFromFormAsync(int folderId, [FromForm] SecurityInfoModel model)
{
return await FilesControllerHelperInt.SetFolderSecurityInfoAsync(folderId, model.Share, model.Notify, model.SharingMessage);
return FilesControllerHelperInt.SetFolderSecurityInfoAsync(folderId, model.Share, model.Notify, model.SharingMessage);
}
/// <summary>
@ -1760,15 +1760,15 @@ namespace ASC.Api.Documents
}
[Update("{fileId:int}/setacelink")]
public async Task<bool> SetAceLinkAsync(int fileId, [FromBody] GenerateSharedLinkModel model)
public Task<bool> SetAceLinkAsync(int fileId, [FromBody] GenerateSharedLinkModel model)
{
return await FilesControllerHelperInt.SetAceLinkAsync(fileId, model.Share);
return FilesControllerHelperInt.SetAceLinkAsync(fileId, model.Share);
}
[Update("{fileId}/setacelink")]
public async Task<bool> SetAceLinkAsync(string fileId, [FromBody] GenerateSharedLinkModel model)
public Task<bool> SetAceLinkAsync(string fileId, [FromBody] GenerateSharedLinkModel model)
{
return await FilesControllerHelperString.SetAceLinkAsync(fileId, model.Share);
return FilesControllerHelperString.SetAceLinkAsync(fileId, model.Share);
}
/// <summary>
@ -1811,16 +1811,16 @@ namespace ASC.Api.Documents
/// <exception cref="ArgumentException"></exception>
[Create("thirdparty")]
public async Task<FolderWrapper<string>> SaveThirdPartyFromBodyAsync([FromBody] ThirdPartyModel model)
public Task<FolderWrapper<string>> SaveThirdPartyFromBodyAsync([FromBody] ThirdPartyModel model)
{
return await SaveThirdPartyAsync(model);
return SaveThirdPartyAsync(model);
}
[Create("thirdparty")]
[Consumes("application/x-www-form-urlencoded")]
public async Task<FolderWrapper<string>> SaveThirdPartyFromFormAsync([FromForm] ThirdPartyModel model)
public Task<FolderWrapper<string>> SaveThirdPartyFromFormAsync([FromForm] ThirdPartyModel model)
{
return await SaveThirdPartyAsync(model);
return SaveThirdPartyAsync(model);
}
private async Task<FolderWrapper<string>> SaveThirdPartyAsync(ThirdPartyModel model)
@ -1879,9 +1879,9 @@ namespace ASC.Api.Documents
///<exception cref="ArgumentException"></exception>
[Delete("thirdparty/{providerId:int}")]
public async Task<object> DeleteThirdPartyAsync(int providerId)
public Task<object> DeleteThirdPartyAsync(int providerId)
{
return await FileStorageService.DeleteThirdPartyAsync(providerId.ToString(CultureInfo.InvariantCulture));
return FileStorageService.DeleteThirdPartyAsync(providerId.ToString(CultureInfo.InvariantCulture));
}
@ -1910,9 +1910,9 @@ namespace ASC.Api.Documents
/// <returns></returns>
[Create("favorites")]
public async Task<bool> AddFavoritesFromBodyAsync([FromBody] BaseBatchModel model)
public Task<bool> AddFavoritesFromBodyAsync([FromBody] BaseBatchModel model)
{
return await AddFavoritesAsync(model);
return AddFavoritesAsync(model);
}
[Create("favorites")]
@ -1933,15 +1933,15 @@ namespace ASC.Api.Documents
}
[Read("favorites/{fileId}")]
public async Task<bool> ToggleFileFavoriteAsync(string fileId, bool favorite)
public Task<bool> ToggleFileFavoriteAsync(string fileId, bool favorite)
{
return await FileStorageService.ToggleFileFavoriteAsync(fileId, favorite);
return FileStorageService.ToggleFileFavoriteAsync(fileId, favorite);
}
[Read("favorites/{fileId:int}")]
public async Task<bool> ToggleFavoriteFromFormAsync(int fileId, bool favorite)
public Task<bool> ToggleFavoriteFromFormAsync(int fileId, bool favorite)
{
return await FileStorageServiceInt.ToggleFileFavoriteAsync(fileId, favorite);
return FileStorageServiceInt.ToggleFileFavoriteAsync(fileId, favorite);
}
/// <summary>
@ -1955,9 +1955,9 @@ namespace ASC.Api.Documents
[Delete("favorites")]
[Consumes("application/json")]
public async Task<bool> DeleteFavoritesFromBodyAsync([FromBody] BaseBatchModel model)
public Task<bool> DeleteFavoritesFromBodyAsync([FromBody] BaseBatchModel model)
{
return await DeleteFavoritesAsync(model);
return DeleteFavoritesAsync(model);
}
[Delete("favorites")]
@ -2256,9 +2256,9 @@ namespace ASC.Api.Documents
/// <returns></returns>
[Create("thumbnails")]
public async Task<IEnumerable<JsonElement>> CreateThumbnailsFromBodyAsync([FromBody] BaseBatchModel model)
public Task<IEnumerable<JsonElement>> CreateThumbnailsFromBodyAsync([FromBody] BaseBatchModel model)
{
return await FileStorageService.CreateThumbnailsAsync(model.FileIds.ToList());
return FileStorageService.CreateThumbnailsAsync(model.FileIds.ToList());
}
[Create("thumbnails")]

8
products/ASC.Files/Server/Controllers/PrivacyRoomController.cs
View File

@ -152,11 +152,11 @@ namespace ASC.Api.Documents
}
[Read("accessAsync/{fileId}")]
public async Task<IEnumerable<EncryptionKeyPair>> GetPublicKeysWithAccessAsync(string fileId)
public Task<IEnumerable<EncryptionKeyPair>> GetPublicKeysWithAccessAsync(string fileId)
{
if (!PrivacyRoomSettings.GetEnabled(SettingsManager)) throw new System.Security.SecurityException();
return await EncryptionKeyPairHelper.GetKeyPairAsync(fileId, FileStorageService);
return EncryptionKeyPairHelper.GetKeyPairAsync(fileId, FileStorageService);
}
[Read("access/{fileId:int}")]
@ -168,11 +168,11 @@ namespace ASC.Api.Documents
}
[Read("accessAsync/{fileId:int}")]
public async Task<IEnumerable<EncryptionKeyPair>> GetPublicKeysWithAccessAsync(int fileId)
public Task<IEnumerable<EncryptionKeyPair>> GetPublicKeysWithAccessAsync(int fileId)
{
if (!PrivacyRoomSettings.GetEnabled(SettingsManager)) throw new System.Security.SecurityException();
return await EncryptionKeyPairHelper.GetKeyPairAsync(fileId, FileStorageServiceInt);
return EncryptionKeyPairHelper.GetKeyPairAsync(fileId, FileStorageServiceInt);
}

56
products/ASC.Files/Server/Helpers/FilesControllerHelper.cs
View File

@ -273,9 +273,9 @@ namespace ASC.Files.Helpers
return FileStorageService.StartEdit(fileId, editingAlone, doc);
}
public async Task<string> StartEditAsync(T fileId, bool editingAlone, string doc)
public Task<string> StartEditAsync(T fileId, bool editingAlone, string doc)
{
return await FileStorageService.StartEditAsync(fileId, editingAlone, doc);
return FileStorageService.StartEditAsync(fileId, editingAlone, doc);
}
public KeyValuePair<bool, string> TrackEditFile(T fileId, Guid tabId, string docKeyForTrack, string doc, bool isFinish)
@ -283,9 +283,9 @@ namespace ASC.Files.Helpers
return FileStorageService.TrackEditFile(fileId, tabId, docKeyForTrack, doc, isFinish);
}
public async Task<KeyValuePair<bool, string>> TrackEditFileAsync(T fileId, Guid tabId, string docKeyForTrack, string doc, bool isFinish)
public Task<KeyValuePair<bool, string>> TrackEditFileAsync(T fileId, Guid tabId, string docKeyForTrack, string doc, bool isFinish)
{
return await FileStorageService.TrackEditFileAsync(fileId, tabId, docKeyForTrack, doc, isFinish);
return FileStorageService.TrackEditFileAsync(fileId, tabId, docKeyForTrack, doc, isFinish);
}
public Configuration<T> OpenEdit(T fileId, int version, string doc, bool view)
@ -426,7 +426,7 @@ namespace ASC.Files.Helpers
using var response = request.GetResponse();
using var responseStream = response.GetResponseStream();
using var streamReader = new StreamReader(responseStream);
return JObject.Parse(streamReader.ReadToEnd()); //result is json string
return JObject.Parse(await streamReader.ReadToEndAsync()); //result is json string
}
public FileWrapper<T> CreateTextFile(T folderId, string title, string content)
@ -444,7 +444,7 @@ namespace ASC.Files.Helpers
return CreateFile(folderId, title, content, extension);
}
public async Task<FileWrapper<T>> CreateTextFileAsync(T folderId, string title, string content)
public Task<FileWrapper<T>> CreateTextFileAsync(T folderId, string title, string content)
{
if (title == null) throw new ArgumentNullException("title");
//Try detect content
@ -456,7 +456,7 @@ namespace ASC.Files.Helpers
extension = ".html";
}
}
return await CreateFileAsync(folderId, title, content, extension);
return CreateFileAsync(folderId, title, content, extension);
}
private FileWrapper<T> CreateFile(T folderId, string title, string content, string extension)
@ -483,10 +483,10 @@ namespace ASC.Files.Helpers
return CreateFile(folderId, title, content, ".html");
}
public async Task<FileWrapper<T>> CreateHtmlFileAsync(T folderId, string title, string content)
public Task<FileWrapper<T>> CreateHtmlFileAsync(T folderId, string title, string content)
{
if (title == null) throw new ArgumentNullException("title");
return await CreateFileAsync(folderId, title, content, ".html");
return CreateFileAsync(folderId, title, content, ".html");
}
public FolderWrapper<T> CreateFolder(T folderId, string title)
@ -676,7 +676,7 @@ namespace ASC.Files.Helpers
new List<string> { fileId.ToString(), "0", start.ToString() }
}, sync);
foreach(var r in checkConversaion)
foreach (var r in checkConversaion)
{
var o = new ConversationResult<T>
{
@ -755,7 +755,7 @@ namespace ASC.Files.Helpers
entries.AddRange(await FileStorageService.GetItemsAsync(checkedFiles.OfType<string>(), checkedFiles.OfType<string>(), FilterType.FilesOnly, false, "", ""));
foreach(var e in entries)
foreach (var e in entries)
{
yield return await GetFileEntryWrapperAsync(e);
}
@ -860,9 +860,9 @@ namespace ASC.Files.Helpers
return FileStorageService.GetPresignedUri(fileId);
}
public async Task<DocumentService.FileLink> GetPresignedUriAsync(T fileId)
public Task<DocumentService.FileLink> GetPresignedUriAsync(T fileId)
{
return await FileStorageService.GetPresignedUriAsync(fileId);
return FileStorageService.GetPresignedUriAsync(fileId);
}
public string UpdateComment(T fileId, int version, string comment)
@ -870,9 +870,9 @@ namespace ASC.Files.Helpers
return FileStorageService.UpdateComment(fileId, version, comment);
}
public async Task<string> UpdateCommentAsync(T fileId, int version, string comment)
public Task<string> UpdateCommentAsync(T fileId, int version, string comment)
{
return await FileStorageService.UpdateCommentAsync(fileId, version, comment);
return FileStorageService.UpdateCommentAsync(fileId, version, comment);
}
public IEnumerable<FileShareWrapper> GetFileSecurityInfo(T fileId)
@ -880,9 +880,9 @@ namespace ASC.Files.Helpers
return GetSecurityInfo(new List<T> { fileId }, new List<T> { });
}
public async Task<IEnumerable<FileShareWrapper>> GetFileSecurityInfoAsync(T fileId)
public Task<IEnumerable<FileShareWrapper>> GetFileSecurityInfoAsync(T fileId)
{
return await GetSecurityInfoAsync(new List<T> { fileId }, new List<T> { });
return GetSecurityInfoAsync(new List<T> { fileId }, new List<T> { });
}
public IEnumerable<FileShareWrapper> GetFolderSecurityInfo(T folderId)
@ -890,9 +890,9 @@ namespace ASC.Files.Helpers
return GetSecurityInfo(new List<T> { }, new List<T> { folderId });
}
public async Task<IEnumerable<FileShareWrapper>> GetFolderSecurityInfoAsync(T folderId)
public Task<IEnumerable<FileShareWrapper>> GetFolderSecurityInfoAsync(T folderId)
{
return await GetSecurityInfoAsync(new List<T> { }, new List<T> { folderId });
return GetSecurityInfoAsync(new List<T> { }, new List<T> { folderId });
}
public IEnumerable<FileEntryWrapper> GetFolders(T folderId)
@ -928,9 +928,9 @@ namespace ASC.Files.Helpers
return SetSecurityInfo(new List<T> { fileId }, new List<T>(), share, notify, sharingMessage);
}
public async Task<IEnumerable<FileShareWrapper>> SetFileSecurityInfoAsync(T fileId, IEnumerable<FileShareParams> share, bool notify, string sharingMessage)
public Task<IEnumerable<FileShareWrapper>> SetFileSecurityInfoAsync(T fileId, IEnumerable<FileShareParams> share, bool notify, string sharingMessage)
{
return await SetSecurityInfoAsync(new List<T> { fileId }, new List<T>(), share, notify, sharingMessage);
return SetSecurityInfoAsync(new List<T> { fileId }, new List<T>(), share, notify, sharingMessage);
}
public IEnumerable<FileShareWrapper> SetFolderSecurityInfo(T folderId, IEnumerable<FileShareParams> share, bool notify, string sharingMessage)
@ -938,9 +938,9 @@ namespace ASC.Files.Helpers
return SetSecurityInfo(new List<T>(), new List<T> { folderId }, share, notify, sharingMessage);
}
public async Task<IEnumerable<FileShareWrapper>> SetFolderSecurityInfoAsync(T folderId, IEnumerable<FileShareParams> share, bool notify, string sharingMessage)
public Task<IEnumerable<FileShareWrapper>> SetFolderSecurityInfoAsync(T folderId, IEnumerable<FileShareParams> share, bool notify, string sharingMessage)
{
return await SetSecurityInfoAsync(new List<T>(), new List<T> { folderId }, share, notify, sharingMessage);
return SetSecurityInfoAsync(new List<T>(), new List<T> { folderId }, share, notify, sharingMessage);
}
public IEnumerable<FileShareWrapper> SetSecurityInfo(IEnumerable<T> fileIds, IEnumerable<T> folderIds, IEnumerable<FileShareParams> share, bool notify, string sharingMessage)
@ -1054,9 +1054,9 @@ namespace ASC.Files.Helpers
return FileStorageService.SetAceLink(fileId, share);
}
public async Task<bool> SetAceLinkAsync(T fileId, FileShare share)
public Task<bool> SetAceLinkAsync(T fileId, FileShare share)
{
return await FileStorageService.SetAceLinkAsync(fileId, share);
return FileStorageService.SetAceLinkAsync(fileId, share);
}
///// <summary>
@ -1083,7 +1083,7 @@ namespace ASC.Files.Helpers
}
var startIndex = Convert.ToInt32(ApiContext.StartIndex);
return await FolderContentWrapperHelper.GetAsync(await FileStorageService.GetFolderItemsAsync(folderId,
var items = await FileStorageService.GetFolderItemsAsync(folderId,
startIndex,
Convert.ToInt32(ApiContext.Count),
filterType,
@ -1092,8 +1092,8 @@ namespace ASC.Files.Helpers
ApiContext.FilterValue,
false,
withSubFolders,
orderBy),
startIndex);
orderBy);
return await FolderContentWrapperHelper.GetAsync(items, startIndex);
}
internal FileEntryWrapper GetFileEntryWrapper(FileEntry r)