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

added async to ISecurityDao

Browse Source
This commit is contained in:
Vashchuk Nikita 2022-01-11 16:15:18 +03:00
parent 0876c22f6f
commit e6f3c19b6e
11 changed files with 243 additions and 426 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -115,32 +115,6 @@ namespace ASC.Files.Core.Data
.Where(where);
}
protected void GetRecalculateFilesCountUpdate(int folderId)
{
var folders = FilesDbContext.Folders
.AsQueryable()
.Where(r => r.TenantId == TenantID)
.Where(r => FilesDbContext.Tree.AsQueryable().Where(r => r.FolderId == folderId).Select(r => r.ParentId).Any(a => a == r.Id))
.ToList();
foreach (var f in folders)
{
var filesCount =
FilesDbContext.Files
.AsQueryable()
.Join(FilesDbContext.Tree, a => a.FolderId, b => b.FolderId, (file, tree) => new { file, tree })
.Where(r => r.file.TenantId == f.TenantId)
.Where(r => r.tree.ParentId == f.Id)
.Select(r => r.file.Id)
.Distinct()
.Count();
f.FilesCount = filesCount;
}
FilesDbContext.SaveChanges();
}
protected async Task GetRecalculateFilesCountUpdateAsync(int folderId)
{
var folders = await FilesDbContext.Folders
@ -151,7 +125,7 @@ namespace ASC.Files.Core.Data
foreach (var f in folders)
{
var filesCount =
f.FilesCount = await
FilesDbContext.Files
.AsQueryable()
.Join(FilesDbContext.Tree, a => a.FolderId, b => b.FolderId, (file, tree) => new { file, tree })
@ -160,53 +134,9 @@ namespace ASC.Files.Core.Data
.Select(r => r.file.Id)
.Distinct()
.CountAsync();
f.FilesCount = await filesCount;
}
FilesDbContext.SaveChanges();
}
protected object MappingID(object id, bool saveIfNotExist)
{
if (id == null) return null;
var isNumeric = int.TryParse(id.ToString(), out var n);
if (isNumeric) return n;
object result;
if (id.ToString().StartsWith("sbox")
|| id.ToString().StartsWith("box")
|| id.ToString().StartsWith("dropbox")
|| id.ToString().StartsWith("spoint")
|| id.ToString().StartsWith("drive")
|| id.ToString().StartsWith("onedrive"))
{
result = Regex.Replace(BitConverter.ToString(Hasher.Hash(id.ToString(), HashAlg.MD5)), "-", "").ToLower();
}
else
{
result = Query(FilesDbContext.ThirdpartyIdMapping)
.Where(r => r.HashId == id.ToString())
.Select(r => r.Id)
.FirstOrDefault();
}
if (saveIfNotExist)
{
var newItem = new DbFilesThirdpartyIdMapping
{
Id = id.ToString(),
HashId = result.ToString(),
TenantId = TenantID
};
FilesDbContext.AddOrUpdate(r => r.ThirdpartyIdMapping, newItem);
}
return result;
await FilesDbContext.SaveChangesAsync();
}
protected async ValueTask<object> MappingIDAsync(object id, bool saveIfNotExist = false)
@ -251,15 +181,9 @@ namespace ASC.Files.Core.Data
return result;
}
protected int MappingID(int id)
protected ValueTask<object> MappingIDAsync(object id)
{
return id;
}
protected object MappingID(object id)
{
return MappingID(id, false);
return MappingIDAsync(id, false);
}
internal static IQueryable<T> BuildSearch<T>(IQueryable<T> query, string text, SearhTypeEnum searhTypeEnum) where T : IDbSearch

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

@ -81,40 +81,43 @@ namespace ASC.Files.Core.Data
{
}
public void DeleteShareRecords(IEnumerable<FileShareRecord> records)
public async Task DeleteShareRecordsAsync(IEnumerable<FileShareRecord> records)
{
using var tx = FilesDbContext.Database.BeginTransaction();
using var tx = await FilesDbContext.Database.BeginTransactionAsync();
foreach (var record in records)
{
var query = FilesDbContext.Security
var query = await FilesDbContext.Security
.AsQueryable()
.Where(r => r.TenantId == record.Tenant)
.Where(r => r.EntryId == MappingID(record.EntryId).ToString())
.Where(r => r.EntryType == record.EntryType)
.Where(r => r.Subject == record.Subject);
.Where(r => r.Subject == record.Subject)
.AsAsyncEnumerable()
.WhereAwait(async r => r.EntryId == (await MappingIDAsync(record.EntryId)).ToString())
.ToListAsync();
FilesDbContext.RemoveRange(query);
}
tx.Commit();
await tx.CommitAsync();
}
public bool IsShared(object entryId, FileEntryType type)
public ValueTask<bool> IsSharedAsync(object entryId, FileEntryType type)
{
return Query(FilesDbContext.Security)
.Any(r => r.EntryId == MappingID(entryId).ToString() &&
.AsAsyncEnumerable()
.AnyAwaitAsync(async r => r.EntryId == (await MappingIDAsync(entryId)).ToString() &&
r.EntryType == type);
}
public void SetShare(FileShareRecord r)
public async Task SetShareAsync(FileShareRecord r)
{
if (r.Share == FileShare.None)
{
var entryId = (MappingID(r.EntryId) ?? "").ToString();
var entryId = (await MappingIDAsync(r.EntryId) ?? "").ToString();
if (string.IsNullOrEmpty(entryId)) return;
using var tx = FilesDbContext.Database.BeginTransaction();
using var tx = await FilesDbContext.Database.BeginTransactionAsync();
var files = new List<string>();
if (r.EntryType == FileEntryType.Folder)
@ -122,14 +125,14 @@ namespace ASC.Files.Core.Data
var folders = new List<string>();
if (int.TryParse(entryId, out var intEntryId))
{
var foldersInt = FilesDbContext.Tree
var foldersInt = await FilesDbContext.Tree
.AsQueryable()
.Where(r => r.ParentId.ToString() == entryId)
.Select(r => r.FolderId)
.ToList();
.ToListAsync();
folders.AddRange(foldersInt.Select(folderInt => folderInt.ToString()));
files.AddRange(Query(FilesDbContext.Files).Where(r => foldersInt.Contains(r.FolderId)).Select(r => r.Id.ToString()));
files.AddRange(await Query(FilesDbContext.Files).Where(r => foldersInt.Contains(r.FolderId)).Select(r => r.Id.ToString()).ToListAsync());
}
else
{
@ -144,7 +147,7 @@ namespace ASC.Files.Core.Data
a.Subject == r.Subject);
FilesDbContext.Security.RemoveRange(toDelete);
FilesDbContext.SaveChanges();
await FilesDbContext.SaveChangesAsync();
}
else
@ -162,17 +165,17 @@ namespace ASC.Files.Core.Data
a.Subject == r.Subject);
FilesDbContext.Security.RemoveRange(toDelete);
FilesDbContext.SaveChanges();
await FilesDbContext.SaveChangesAsync();
}
tx.Commit();
await tx.CommitAsync();
}
else
{
var toInsert = new DbFilesSecurity
{
TenantId = r.Tenant,
EntryId = MappingID(r.EntryId, true).ToString(),
EntryId = (await MappingIDAsync(r.EntryId, true)).ToString(),
EntryType = r.EntryType,
Subject = r.Subject,
Owner = r.Owner,
@ -180,18 +183,18 @@ namespace ASC.Files.Core.Data
TimeStamp = DateTime.UtcNow
};
FilesDbContext.AddOrUpdate(r => r.Security, toInsert);
FilesDbContext.SaveChanges();
await FilesDbContext.AddOrUpdateAsync(r => r.Security, toInsert);
await FilesDbContext.SaveChangesAsync();
}
}
public IEnumerable<FileShareRecord> GetShares(IEnumerable<Guid> subjects)
public ValueTask<List<FileShareRecord>> GetSharesAsync(IEnumerable<Guid> subjects)
{
var q = GetQuery(r => subjects.Contains(r.Subject));
return FromQuery(q);
return FromQueryAsync(q);
}
public IEnumerable<FileShareRecord> GetPureShareRecords(IEnumerable<FileEntry<T>> entries)
public async Task<IEnumerable<FileShareRecord>> GetPureShareRecordsAsync(IEnumerable<FileEntry<T>> entries)
{
if (entries == null) return new List<FileShareRecord>();
@ -200,10 +203,10 @@ namespace ASC.Files.Core.Data
foreach (var entry in entries)
{
SelectFilesAndFoldersForShare(entry, files, folders, null);
await SelectFilesAndFoldersForShareAsync(entry, files, folders, null);
}
return GetPureShareRecordsDb(files, folders);
return await GetPureShareRecordsDbAsync(files, folders);
}
public async Task<IEnumerable<FileShareRecord>> GetPureShareRecordsAsync(IAsyncEnumerable<FileEntry<T>> entries)
@ -218,35 +221,19 @@ namespace ASC.Files.Core.Data
await SelectFilesAndFoldersForShareAsync(entry, files, folders, null);
}
return GetPureShareRecordsDb(files, folders);
return await GetPureShareRecordsDbAsync(files, folders);
}
public IEnumerable<FileShareRecord> GetPureShareRecords(FileEntry<T> entry)
public async Task<IEnumerable<FileShareRecord>> GetPureShareRecordsAsync(FileEntry<T> entry)
{
if (entry == null) return new List<FileShareRecord>();
var files = new List<string>();
var folders = new List<string>();
SelectFilesAndFoldersForShare(entry, files, folders, null);
await SelectFilesAndFoldersForShareAsync(entry, files, folders, null);
return GetPureShareRecordsDb(files, folders);
}
private IEnumerable<FileShareRecord> GetPureShareRecordsDb(List<string> files, List<string> folders)
{
var result = new List<FileShareRecord>();
var q = GetQuery(r => folders.Contains(r.EntryId) && r.EntryType == FileEntryType.Folder);
if (files.Any())
{
q = q.Union(GetQuery(r => files.Contains(r.EntryId) && r.EntryType == FileEntryType.File));
}
result.AddRange(FromQuery(q));
return result;
return await GetPureShareRecordsDbAsync(files, folders);
}
private async Task<IEnumerable<FileShareRecord>> GetPureShareRecordsDbAsync(List<string> files, List<string> folders)
@ -270,7 +257,7 @@ namespace ASC.Files.Core.Data
/// </summary>
/// <param name="entries"></param>
/// <returns></returns>
public IEnumerable<FileShareRecord> GetShares(IEnumerable<FileEntry<T>> entries)
public async Task<IEnumerable<FileShareRecord>> GetSharesAsync(IEnumerable<FileEntry<T>> entries)
{
if (entries == null) return new List<FileShareRecord>();
@ -279,10 +266,10 @@ namespace ASC.Files.Core.Data
foreach (var entry in entries)
{
SelectFilesAndFoldersForShare(entry, files, null, foldersInt);
await SelectFilesAndFoldersForShareAsync(entry, files, null, foldersInt);
}
return SaveFilesAndFoldersForShare(files, foldersInt);
return await SaveFilesAndFoldersForShareAsync(files, foldersInt);
}
/// <summary>
@ -290,34 +277,15 @@ namespace ASC.Files.Core.Data
/// </summary>
/// <param name="entry"></param>
/// <returns></returns>
public IEnumerable<FileShareRecord> GetShares(FileEntry<T> entry)
public async Task<IEnumerable<FileShareRecord>> GetSharesAsync(FileEntry<T> entry)
{
if (entry == null) return new List<FileShareRecord>();
var files = new List<string>();
var foldersInt = new List<int>();
SelectFilesAndFoldersForShare(entry, files, null, foldersInt);
return SaveFilesAndFoldersForShare(files, foldersInt);
}
private void SelectFilesAndFoldersForShare(FileEntry<T> entry, ICollection<string> files, ICollection<string> folders, ICollection<int> foldersInt)
{
T folderId;
if (entry.FileEntryType == FileEntryType.File)
{
var fileId = MappingID(entry.ID);
folderId = ((File<T>)entry).FolderID;
if (!files.Contains(fileId.ToString())) files.Add(fileId.ToString());
}
else
{
folderId = entry.ID;
}
if (foldersInt != null && int.TryParse(folderId.ToString(), out var folderIdInt) && !foldersInt.Contains(folderIdInt)) foldersInt.Add(folderIdInt);
if (folders != null) folders.Add(MappingID(folderId).ToString());
await SelectFilesAndFoldersForShareAsync(entry, files, null, foldersInt);
return await SaveFilesAndFoldersForShareAsync(files, foldersInt);
}
private async Task SelectFilesAndFoldersForShareAsync(FileEntry<T> entry, ICollection<string> files, ICollection<string> folders, ICollection<int> foldersInt)
@ -340,42 +308,41 @@ namespace ASC.Files.Core.Data
if (folders != null) folders.Add(mappedId.ToString());
}
private IEnumerable<FileShareRecord> SaveFilesAndFoldersForShare(List<string> files, List<int> folders)
private async Task<IEnumerable<FileShareRecord>> SaveFilesAndFoldersForShareAsync(List<string> files, List<int> folders)
{
var q = Query(FilesDbContext.Security)
.Join(FilesDbContext.Tree, r => r.EntryId, a => a.ParentId.ToString(), (security, tree) => new SecurityTreeRecord { DbFilesSecurity = security, DbFolderTree = tree })
.Where(r => folders.Contains(r.DbFolderTree.FolderId) &&
r.DbFilesSecurity.EntryType == FileEntryType.Folder)
.ToList();
r.DbFilesSecurity.EntryType == FileEntryType.Folder);
if (0 < files.Count)
{
var q1 = GetQuery(r => files.Contains(r.EntryId) && r.EntryType == FileEntryType.File)
.Select(r => new SecurityTreeRecord { DbFilesSecurity = r })
.ToList();
q = q.Union(q1).ToList();
.Select(r => new SecurityTreeRecord { DbFilesSecurity = r });
q = q.Union(q1);
}
return q.Select(ToFileShareRecord)
return await q.AsAsyncEnumerable()
.SelectAwait(async e => await ToFileShareRecordAsync(e))
.OrderBy(r => r.Level)
.ThenByDescending(r => r.Share, new FileShareRecord.ShareComparer())
.ToList();
.ToListAsync();
}
public void RemoveSubject(Guid subject)
public async Task RemoveSubjectAsync(Guid subject)
{
using var tr = FilesDbContext.Database.BeginTransaction();
using var tr = await FilesDbContext.Database.BeginTransactionAsync();
var toDelete1 = FilesDbContext.Security.AsQueryable().Where(r => r.Subject == subject);
var toDelete2 = FilesDbContext.Security.AsQueryable().Where(r => r.Owner == subject);
FilesDbContext.RemoveRange(toDelete1);
FilesDbContext.SaveChanges();
await FilesDbContext.SaveChangesAsync();
FilesDbContext.RemoveRange(toDelete2);
FilesDbContext.SaveChanges();
await FilesDbContext.SaveChangesAsync();
tr.Commit();
await tr.CommitAsync();
}
private IQueryable<DbFilesSecurity> GetQuery(Expression<Func<DbFilesSecurity, bool>> where = null)
@ -388,36 +355,20 @@ namespace ASC.Files.Core.Data
return q;
}
protected List<FileShareRecord> FromQuery(IQueryable<DbFilesSecurity> filesSecurities)
protected ValueTask<List<FileShareRecord>> FromQueryAsync(IQueryable<DbFilesSecurity> filesSecurities)
{
return filesSecurities
.ToList()
.Select(ToFileShareRecord)
.ToList();
.AsAsyncEnumerable()
.SelectAwait(async e => await ToFileShareRecordAsync(e))
.ToListAsync();
}
protected async Task<List<FileShareRecord>> FromQueryAsync(IQueryable<DbFilesSecurity> filesSecurities)
{
var files = await filesSecurities.ToListAsync();
return files
.Select(ToFileShareRecord)
.ToList();
}
protected List<FileShareRecord> FromQuery(IQueryable<SecurityTreeRecord> filesSecurities)
{
return filesSecurities
.ToList()
.Select(ToFileShareRecord)
.ToList();
}
private FileShareRecord ToFileShareRecord(DbFilesSecurity r)
private async Task<FileShareRecord> ToFileShareRecordAsync(DbFilesSecurity r)
{
return new FileShareRecord
{
Tenant = r.TenantId,
EntryId = MappingID(r.EntryId),
EntryId = await MappingIDAsync(r.EntryId),
EntryType = r.EntryType,
Subject = r.Subject,
Owner = r.Owner,
@ -425,9 +376,9 @@ namespace ASC.Files.Core.Data
};
}
private FileShareRecord ToFileShareRecord(SecurityTreeRecord r)
private async Task<FileShareRecord> ToFileShareRecordAsync(SecurityTreeRecord r)
{
var result = ToFileShareRecord(r.DbFilesSecurity);
var result = await ToFileShareRecordAsync(r.DbFilesSecurity);
if (r.DbFolderTree != null)
{
result.EntryId = r.DbFolderTree.FolderId;

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

@ -178,7 +178,7 @@ ctx.Tag
.Join(FilesDbContext.TagLink, r => r.Id, l => l.TagId, (tag, link) => new TagLinkData { Tag = tag, Link = link })
.Where(r => r.Link.TenantId == r.Tag.TenantId)
.Where(r => r.Link.EntryType == entryType)
.Where(r => r.Link.EntryId == MappingID(entryID).ToString())
.Where(r => r.Link.EntryId == MappingIDAsync(entryID).Result.ToString())
.Where(r => r.Tag.Flag == tagType);
await foreach (var e in FromQueryAsync(q).ConfigureAwait(false))
@ -250,7 +250,7 @@ ctx.Tag
var createOn = TenantUtil.DateTimeToUtc(TenantUtil.DateTimeNow());
var cacheTagId = new Dictionary<string, int>();
result.AddRange(tags.Select(t => SaveTag(t, cacheTagId, createOn)));
result.AddRange(tags.Select(t => SaveTagAsync(t, cacheTagId, createOn).Result));
tx.Commit();
}
@ -274,7 +274,7 @@ ctx.Tag
var createOn = TenantUtil.DateTimeToUtc(TenantUtil.DateTimeNow());
var cacheTagId = new Dictionary<string, int>();
result.Add(SaveTag(tag, cacheTagId, createOn));
result.Add(SaveTagAsync(tag, cacheTagId, createOn).Result);
tx.Commit();
}
@ -310,19 +310,19 @@ ctx.Tag
FilesDbContext.SaveChanges();
}
private Tag SaveTag(Tag t, Dictionary<string, int> cacheTagId, DateTime createOn)
private async Task<Tag> SaveTagAsync(Tag t, Dictionary<string, int> cacheTagId, DateTime createOn)
{
var cacheTagIdKey = string.Join("/", new[] { TenantID.ToString(), t.Owner.ToString(), t.TagName, ((int)t.TagType).ToString(CultureInfo.InvariantCulture) });
if (!cacheTagId.TryGetValue(cacheTagIdKey, out var id))
{
id = FilesDbContext.Tag
id = await FilesDbContext.Tag
.AsQueryable()
.Where(r => r.Owner == t.Owner)
.Where(r => r.Name == t.TagName)
.Where(r => r.Flag == t.TagType)
.Select(r => r.Id)
.FirstOrDefault();
.FirstOrDefaultAsync();
if (id == 0)
{
@ -336,7 +336,7 @@ ctx.Tag
};
toAdd = FilesDbContext.Tag.Add(toAdd).Entity;
FilesDbContext.SaveChanges();
await FilesDbContext.SaveChangesAsync();
id = toAdd.Id;
}
@ -349,15 +349,15 @@ ctx.Tag
{
TenantId = TenantID,
TagId = id,
EntryId = MappingID(t.EntryId, true).ToString(),
EntryId = (await MappingIDAsync(t.EntryId, true)).ToString(),
EntryType = t.EntryType,
CreateBy = AuthContext.CurrentAccount.ID,
CreateOn = createOn,
TagCount = t.Count
};
FilesDbContext.AddOrUpdate(r => r.TagLink, linkToInsert);
FilesDbContext.SaveChanges();
await FilesDbContext.AddOrUpdateAsync(r => r.TagLink, linkToInsert);
await FilesDbContext.SaveChangesAsync();
return t;
}
@ -373,7 +373,7 @@ ctx.Tag
foreach (var tag in tags)
{
UpdateNewTagsInDb(tag, createOn);
UpdateNewTagsInDbAsync(tag, createOn).Wait();
}
tx.Commit();
}
@ -387,18 +387,18 @@ ctx.Tag
{
var createOn = TenantUtil.DateTimeToUtc(TenantUtil.DateTimeNow());
UpdateNewTagsInDb(tag, createOn);
UpdateNewTagsInDbAsync(tag, createOn).Wait();
}
}
private void UpdateNewTagsInDb(Tag tag, DateTime createOn)
private async Task UpdateNewTagsInDbAsync(Tag tag, DateTime createOn)
{
if (tag == null) return;
var forUpdate = Query(FilesDbContext.TagLink)
.Where(r => r.TagId == tag.Id)
.Where(r => r.EntryType == tag.EntryType)
.Where(r => r.EntryId == MappingID(tag.EntryId).ToString());
.Where(r => r.EntryId == MappingIDAsync(tag.EntryId).Result.ToString());
foreach (var f in forUpdate)
{
@ -407,7 +407,7 @@ ctx.Tag
f.TagCount = tag.Count;
}
FilesDbContext.SaveChanges();
await FilesDbContext.SaveChangesAsync();
}
public void RemoveTags(IEnumerable<Tag> tags)
@ -419,7 +419,7 @@ ctx.Tag
using var tx = FilesDbContext.Database.BeginTransaction();
foreach (var t in tags)
{
RemoveTagInDb(t);
RemoveTagInDbAsync(t).Wait();
}
tx.Commit();
}
@ -432,44 +432,12 @@ ctx.Tag
lock (syncRoot)
{
using var tx = FilesDbContext.Database.BeginTransaction();
RemoveTagInDb(tag);
RemoveTagInDbAsync(tag).Wait();
tx.Commit();
}
}
private void RemoveTagInDb(Tag tag)
{
if (tag == null) return;
var id = Query(FilesDbContext.Tag)
.Where(r => r.Name == tag.TagName &&
r.Owner == tag.Owner &&
r.Flag == tag.TagType)
.Select(r => r.Id)
.FirstOrDefault();
if (id != 0)
{
var entryId = MappingID(tag.EntryId).ToString();
var toDelete = Query(FilesDbContext.TagLink)
.Where(r => r.TagId == id &&
r.EntryId == entryId &&
r.EntryType == tag.EntryType);
FilesDbContext.TagLink.RemoveRange(toDelete);
FilesDbContext.SaveChanges();
var count = Query(FilesDbContext.TagLink).Count(r => r.TagId == id);
if (count == 0)
{
var tagToDelete = Query(FilesDbContext.Tag).Where(r => r.Id == id);
FilesDbContext.Tag.RemoveRange(tagToDelete);
FilesDbContext.SaveChanges();
}
}
}
private async Task RemoveTagInDbAsync(Tag tag)
{
if (tag == null) return;

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

@ -2001,7 +2001,7 @@ namespace ASC.Web.Files.Services.WCFService
}
var securityDao = GetSecurityDao();
if (securityDao.IsShared(entry.ID, entry.FileEntryType))
if (await securityDao.IsSharedAsync(entry.ID, entry.FileEntryType))
{
result.Add(entry.ID);
}
@ -2009,19 +2009,6 @@ namespace ASC.Web.Files.Services.WCFService
return result;
}
public void RemoveAce(List<T> filesId, List<T> foldersId)
{
ErrorIf(!AuthContext.IsAuthenticated, FilesCommonResource.ErrorMassage_SecurityException);
var entries = new List<FileEntry<T>>();
var fileDao = GetFileDao();
var folderDao = GetFolderDao();
entries.AddRange(filesId.Select(fileId => fileDao.GetFileAsync(fileId).Result));
entries.AddRange(foldersId.Select(e => folderDao.GetFolderAsync(e).Result));
FileSharingAceHelper.RemoveAce(entries);
}
public Task RemoveAceAsync(List<T> filesId, List<T> foldersId)
{
ErrorIf(!AuthContext.IsAuthenticated, FilesCommonResource.ErrorMassage_SecurityException);
@ -2084,7 +2071,7 @@ namespace ASC.Web.Files.Services.WCFService
}
var securityDao = GetSecurityDao();
return securityDao.IsShared(file.ID, FileEntryType.File);
return await securityDao.IsSharedAsync(file.ID, FileEntryType.File);
}
public async Task<List<MentionWrapper>> SharedUsersAsync(T fileId)

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

@ -679,7 +679,7 @@ namespace ASC.Files.Core.Security
return result;
}
public void Share<T>(T entryId, FileEntryType entryType, Guid @for, FileShare share)
public async Task ShareAsync<T>(T entryId, FileEntryType entryType, Guid @for, FileShare share)
{
var securityDao = daoFactory.GetSecurityDao<T>();
var r = new FileShareRecord
@ -691,24 +691,34 @@ namespace ASC.Files.Core.Security
Owner = AuthContext.CurrentAccount.ID,
Share = share,
};
securityDao.SetShare(r);
await securityDao.SetShareAsync(r);
}
public IEnumerable<FileShareRecord> GetShares<T>(IEnumerable<FileEntry<T>> entries)
{
return daoFactory.GetSecurityDao<T>().GetShares(entries);
return daoFactory.GetSecurityDao<T>().GetSharesAsync(entries).Result;
}
public async Task<IEnumerable<FileShareRecord>> GetSharesAsync<T>(IEnumerable<FileEntry<T>> entries)
{
return await daoFactory.GetSecurityDao<T>().GetSharesAsync(entries);
}
public IEnumerable<FileShareRecord> GetShares<T>(FileEntry<T> entry)
{
return daoFactory.GetSecurityDao<T>().GetShares(entry);
return daoFactory.GetSecurityDao<T>().GetSharesAsync(entry).Result;
}
public async Task<IEnumerable<FileShareRecord>> GetSharesAsync<T>(FileEntry<T> entry)
{
return await daoFactory.GetSecurityDao<T>().GetSharesAsync(entry);
}
public async Task<List<FileEntry>> GetSharesForMeAsync(FilterType filterType, bool subjectGroup, Guid subjectID, string searchText = "", bool searchInContent = false, bool withSubfolders = false)
{
var securityDao = daoFactory.GetSecurityDao<int>();
var subjects = GetUserSubjects(AuthContext.CurrentAccount.ID);
var records = securityDao.GetShares(subjects);
IEnumerable<FileShareRecord> records = await securityDao.GetSharesAsync(subjects);
var result = new List<FileEntry>();
result.AddRange(await GetSharesForMeAsync<int>(records.Where(r => r.EntryId.GetType() == typeof(int)), subjects, filterType, subjectGroup, subjectID, searchText, searchInContent, withSubfolders));
@ -819,7 +829,7 @@ namespace ASC.Files.Core.Security
if (failedRecords.Any())
{
securityDao.DeleteShareRecords(failedRecords);
await securityDao.DeleteShareRecordsAsync(failedRecords);
}
return entries.Where(x => string.IsNullOrEmpty(x.Error)).Cast<FileEntry>().ToList();
@ -829,7 +839,7 @@ namespace ASC.Files.Core.Security
{
var securityDao = daoFactory.GetSecurityDao<int>();
var subjects = GetUserSubjects(AuthContext.CurrentAccount.ID);
var records = securityDao.GetShares(subjects);
IEnumerable<FileShareRecord> records = await securityDao.GetSharesAsync(subjects);
var result = new List<FileEntry>();
result.AddRange(await GetPrivacyForMeAsync<int>(records.Where(r => r.EntryId.GetType() == typeof(int)), subjects, filterType, subjectGroup, subjectID, searchText, searchInContent, withSubfolders));
@ -921,10 +931,9 @@ namespace ASC.Files.Core.Security
return entries;
}
public void RemoveSubject<T>(Guid subject)
public async Task RemoveSubjectAsync<T>(Guid subject)
{
daoFactory.GetSecurityDao<T>().RemoveSubject(subject);
await daoFactory.GetSecurityDao<T>().RemoveSubjectAsync(subject);
}
public List<Guid> GetUserSubjects(Guid userId)

19
products/ASC.Files/Core/Core/Security/ISecurityDao.cs
View File

@ -26,6 +26,7 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using ASC.Common;
@ -34,22 +35,22 @@ namespace ASC.Files.Core.Security
[Scope]
public interface ISecurityDao<T>
{
void SetShare(FileShareRecord r);
Task SetShareAsync(FileShareRecord r);
IEnumerable<FileShareRecord> GetShares(IEnumerable<Guid> subjects);
ValueTask<List<FileShareRecord>> GetSharesAsync(IEnumerable<Guid> subjects);
IEnumerable<FileShareRecord> GetShares(IEnumerable<FileEntry<T>> entry);
Task<IEnumerable<FileShareRecord>> GetSharesAsync(IEnumerable<FileEntry<T>> entry);
IEnumerable<FileShareRecord> GetShares(FileEntry<T> entry);
Task<IEnumerable<FileShareRecord>> GetSharesAsync(FileEntry<T> entry);
void RemoveSubject(Guid subject);
Task RemoveSubjectAsync(Guid subject);
IEnumerable<FileShareRecord> GetPureShareRecords(IEnumerable<FileEntry<T>> entries);
Task<IEnumerable<FileShareRecord>> GetPureShareRecordsAsync(IEnumerable<FileEntry<T>> entries);
IEnumerable<FileShareRecord> GetPureShareRecords(FileEntry<T> entry);
Task<IEnumerable<FileShareRecord>> GetPureShareRecordsAsync(FileEntry<T> entry);
void DeleteShareRecords(IEnumerable<FileShareRecord> records);
Task DeleteShareRecordsAsync(IEnumerable<FileShareRecord> records);
bool IsShared(object entryId, FileEntryType type);
ValueTask<bool> IsSharedAsync(object entryId, FileEntryType type);
}
}

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

@ -53,11 +53,11 @@ namespace ASC.Files.Core.Thirdparty
var securityDao = ServiceProvider.GetService<ISecurityDao<TFrom>>();
var tagDao = ServiceProvider.GetService<ITagDao<TFrom>>();
var fromFileShareRecords = securityDao.GetPureShareRecords(fromFile).Where(x => x.EntryType == FileEntryType.File);
var fromFileNewTags = tagDao.GetNewTagsAsync(Guid.Empty, fromFile).ToListAsync().Result;
var fromFileLockTag = tagDao.GetTagsAsync(fromFile.ID, FileEntryType.File, TagType.Locked).ToListAsync().Result.FirstOrDefault();
var fromFileFavoriteTag = tagDao.GetTagsAsync(fromFile.ID, FileEntryType.File, TagType.Favorite).ToListAsync().Result;
var fromFileTemplateTag = tagDao.GetTagsAsync(fromFile.ID, FileEntryType.File, TagType.Template).ToListAsync().Result;
var fromFileShareRecords = (await securityDao.GetPureShareRecordsAsync(fromFile)).Where(x => x.EntryType == FileEntryType.File);
var fromFileNewTags = await tagDao.GetNewTagsAsync(Guid.Empty, fromFile).ToListAsync();
var fromFileLockTag = (await tagDao.GetTagsAsync(fromFile.ID, FileEntryType.File, TagType.Locked).ToListAsync()).FirstOrDefault();
var fromFileFavoriteTag = await tagDao.GetTagsAsync(fromFile.ID, FileEntryType.File, TagType.Favorite).ToListAsync();
var fromFileTemplateTag = await tagDao.GetTagsAsync(fromFile.ID, FileEntryType.File, TagType.Template).ToListAsync();
var toFile = ServiceProvider.GetService<File<TTo>>();
@ -91,7 +91,7 @@ namespace ASC.Files.Core.Thirdparty
fromFileShareRecords.ToList().ForEach(x =>
{
x.EntryId = toFile.ID;
securityDao.SetShare(x);
securityDao.SetShareAsync(x).Wait();
});
var fromFileTags = fromFileNewTags;
@ -164,7 +164,7 @@ namespace ASC.Files.Core.Thirdparty
if (deleteSourceFolder)
{
var securityDao = ServiceProvider.GetService<ISecurityDao<TFrom>>();
var fromFileShareRecords = securityDao.GetPureShareRecords(fromFolder)
var fromFileShareRecords = (await securityDao.GetPureShareRecordsAsync(fromFolder))
.Where(x => x.EntryType == FileEntryType.Folder);
if (fromFileShareRecords.Any())
@ -172,7 +172,7 @@ namespace ASC.Files.Core.Thirdparty
fromFileShareRecords.ToList().ForEach(x =>
{
x.EntryId = toFolderId;
securityDao.SetShare(x);
securityDao.SetShareAsync(x).Wait();
});
}

37
products/ASC.Files/Core/Core/Thirdparty/IThirdPartyProviderDao.cs vendored
View File

@ -389,45 +389,48 @@ namespace ASC.Files.Thirdparty
#region SecurityDao
public void SetShare(FileShareRecord r)
public Task SetShareAsync(FileShareRecord r)
{
return Task.CompletedTask;
}
public IEnumerable<FileShareRecord> GetShares(IEnumerable<Guid> subjects)
public ValueTask<List<FileShareRecord>> GetSharesAsync(IEnumerable<Guid> subjects)
{
List<FileShareRecord> result = null;
return new ValueTask<List<FileShareRecord>>(result);
}
public Task<IEnumerable<FileShareRecord>> GetSharesAsync(IEnumerable<FileEntry<string>> entry)
{
return null;
}
public IEnumerable<FileShareRecord> GetShares(IEnumerable<FileEntry<string>> entry)
public Task<IEnumerable<FileShareRecord>> GetSharesAsync(FileEntry<string> entry)
{
return null;
}
public IEnumerable<FileShareRecord> GetShares(FileEntry<string> entry)
public Task RemoveSubjectAsync(Guid subject)
{
return Task.CompletedTask;
}
public Task<IEnumerable<FileShareRecord>> GetPureShareRecordsAsync(IEnumerable<FileEntry<string>> entries)
{
return null;
}
public void RemoveSubject(Guid subject)
{
}
public IEnumerable<FileShareRecord> GetPureShareRecords(IEnumerable<FileEntry<string>> entries)
public Task<IEnumerable<FileShareRecord>> GetPureShareRecordsAsync(FileEntry<string> entry)
{
return null;
}
public IEnumerable<FileShareRecord> GetPureShareRecords(FileEntry<string> entry)
public Task DeleteShareRecordsAsync(IEnumerable<FileShareRecord> records)
{
return null;
return Task.CompletedTask;
}
public void DeleteShareRecords(IEnumerable<FileShareRecord> records)
{
}
public bool IsShared(object entryId, FileEntryType type)
public ValueTask<bool> IsSharedAsync(object entryId, FileEntryType type)
{
throw new NotImplementedException();
}

55
products/ASC.Files/Core/Core/Thirdparty/ProviderDao/ProviderSecutiryDao.cs vendored
View File

@ -27,6 +27,7 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using ASC.Common;
using ASC.Core;
@ -52,12 +53,12 @@ namespace ASC.Files.Thirdparty.ProviderDao
{
}
public void SetShare(FileShareRecord r)
public async Task SetShareAsync(FileShareRecord r)
{
SecurityDao.SetShare(r);
await SecurityDao.SetShareAsync(r);
}
public IEnumerable<FileShareRecord> GetShares(IEnumerable<FileEntry<string>> entries)
public async Task<IEnumerable<FileShareRecord>> GetSharesAsync(IEnumerable<FileEntry<string>> entries)
{
var result = new List<FileShareRecord>();
@ -69,10 +70,10 @@ namespace ASC.Files.Thirdparty.ProviderDao
var folderIds = files.Select(x => ((File<string>)x).FolderID).Distinct();
foreach (var folderId in folderIds)
{
GetFoldersForShare(folderId, folders);
await GetFoldersForShareAsync(folderId, folders);
}
var pureShareRecords = SecurityDao.GetPureShareRecords(files);
var pureShareRecords = await SecurityDao.GetPureShareRecordsAsync(files);
if (pureShareRecords != null)
{
foreach (var pureShareRecord in pureShareRecords)
@ -84,12 +85,12 @@ namespace ASC.Files.Thirdparty.ProviderDao
}
}
result.AddRange(GetShareForFolders(folders));
result.AddRange(GetShareForFoldersAsync(folders).Result);
return result;
}
public IEnumerable<FileShareRecord> GetShares(FileEntry<string> entry)
public async Task<IEnumerable<FileShareRecord>> GetSharesAsync(FileEntry<string> entry)
{
var result = new List<FileShareRecord>();
@ -104,9 +105,9 @@ namespace ASC.Files.Thirdparty.ProviderDao
if (entry is File<string> file)
{
GetFoldersForShare(file.FolderID, folders);
await GetFoldersForShareAsync(file.FolderID, folders);
var pureShareRecords = SecurityDao.GetPureShareRecords(entry);
var pureShareRecords = await SecurityDao.GetPureShareRecordsAsync(entry);
if (pureShareRecords != null)
{
foreach (var pureShareRecord in pureShareRecords)
@ -118,22 +119,22 @@ namespace ASC.Files.Thirdparty.ProviderDao
}
}
result.AddRange(GetShareForFolders(folders));
result.AddRange(await GetShareForFoldersAsync(folders));
return result;
}
private void GetFoldersForShare(string folderId, ICollection<FileEntry<string>> folders)
private async Task GetFoldersForShareAsync(string folderId, ICollection<FileEntry<string>> folders)
{
var selector = GetSelector(folderId);
var folderDao = selector.GetFolderDao(folderId);
if (folderDao == null) return;
var folder = folderDao.GetFolderAsync(selector.ConvertId(folderId)).Result;
var folder = await folderDao.GetFolderAsync(selector.ConvertId(folderId));
if (folder != null) folders.Add(folder);
}
private List<FileShareRecord> GetShareForFolders(IReadOnlyCollection<FileEntry<string>> folders)
private async Task<List<FileShareRecord>> GetShareForFoldersAsync(IReadOnlyCollection<FileEntry<string>> folders)
{
if (!folders.Any()) return new List<FileShareRecord>();
@ -145,11 +146,11 @@ namespace ASC.Files.Thirdparty.ProviderDao
var folderDao = selector.GetFolderDao(folder.ID);
if (folderDao == null) continue;
var parentFolders = folderDao.GetParentFoldersAsync(selector.ConvertId(folder.ID)).Result;
var parentFolders = await folderDao.GetParentFoldersAsync(selector.ConvertId(folder.ID));
if (parentFolders == null || !parentFolders.Any()) continue;
parentFolders.Reverse();
var pureShareRecords = GetPureShareRecords(parentFolders);
var pureShareRecords = await GetPureShareRecordsAsync(parentFolders);
if (pureShareRecords == null) continue;
foreach (var pureShareRecord in pureShareRecords)
@ -167,34 +168,34 @@ namespace ASC.Files.Thirdparty.ProviderDao
return result;
}
public void RemoveSubject(Guid subject)
public async Task RemoveSubjectAsync(Guid subject)
{
SecurityDao.RemoveSubject(subject);
await SecurityDao.RemoveSubjectAsync(subject);
}
public IEnumerable<FileShareRecord> GetShares(IEnumerable<Guid> subjects)
public ValueTask<List<FileShareRecord>> GetSharesAsync(IEnumerable<Guid> subjects)
{
return SecurityDao.GetShares(subjects);
return SecurityDao.GetSharesAsync(subjects);
}
public IEnumerable<FileShareRecord> GetPureShareRecords(IEnumerable<FileEntry<string>> entries)
public async Task<IEnumerable<FileShareRecord>> GetPureShareRecordsAsync(IEnumerable<FileEntry<string>> entries)
{
return SecurityDao.GetPureShareRecords(entries);
return await SecurityDao.GetPureShareRecordsAsync(entries);
}
public IEnumerable<FileShareRecord> GetPureShareRecords(FileEntry<string> entry)
public async Task<IEnumerable<FileShareRecord>> GetPureShareRecordsAsync(FileEntry<string> entry)
{
return SecurityDao.GetPureShareRecords(entry);
return await SecurityDao.GetPureShareRecordsAsync(entry);
}
public void DeleteShareRecords(IEnumerable<FileShareRecord> records)
public async Task DeleteShareRecordsAsync(IEnumerable<FileShareRecord> records)
{
SecurityDao.DeleteShareRecords(records);
await SecurityDao.DeleteShareRecordsAsync(records);
}
public bool IsShared(object entryId, FileEntryType type)
public async ValueTask<bool> IsSharedAsync(object entryId, FileEntryType type)
{
return SecurityDao.IsShared(entryId, type);
return await SecurityDao.IsSharedAsync(entryId, type);
}
}
}

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

@ -622,7 +622,7 @@ namespace ASC.Web.Files.Utils
if (folderList.Any())
{
var securityDao = DaoFactory.GetSecurityDao<string>();
securityDao.GetPureShareRecords(folderList)
(await securityDao.GetPureShareRecordsAsync(folderList))
//.Where(x => x.Owner == SecurityContext.CurrentAccount.ID)
.Select(x => x.EntryId).Distinct().ToList()
.ForEach(id =>

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

@ -119,7 +119,7 @@ namespace ASC.Web.Files.Utils
share = w.Share == FileShare.Restrict ? FileShare.None : w.Share;
}
fileSecurity.Share(entry.ID, entryType, w.SubjectId, share);
await fileSecurity.ShareAsync(entry.ID, entryType, w.SubjectId, share);
changed = true;
if (w.SubjectId == FileConstant.ShareLinkId)
@ -190,33 +190,6 @@ namespace ASC.Web.Files.Utils
return changed;
}
public void RemoveAce(List<FileEntry<T>> entries)
{
var fileSecurity = FileSecurity;
entries.ForEach(
entry =>
{
if (entry.RootFolderType != FolderType.USER && entry.RootFolderType != FolderType.Privacy
|| Equals(entry.RootFolderId, GlobalFolderHelper.FolderMy)
|| Equals(entry.RootFolderId, GlobalFolderHelper.FolderPrivacy))
return;
var entryType = entry.FileEntryType;
fileSecurity.Share(entry.ID, entryType, AuthContext.CurrentAccount.ID,
entry.RootFolderType == FolderType.USER
? fileSecurity.DefaultMyShare
: fileSecurity.DefaultPrivacyShare);
if (entryType == FileEntryType.File)
{
DocumentServiceHelper.CheckUsersForDrop((File<T>)entry);
}
FileMarker.RemoveMarkAsNew(entry);
});
}
public Task RemoveAceAsync(IAsyncEnumerable<FileEntry<T>> entries)
{
var fileSecurity = FileSecurity;
@ -230,7 +203,7 @@ namespace ASC.Web.Files.Utils
return;
var entryType = entry.FileEntryType;
fileSecurity.Share(entry.ID, entryType, AuthContext.CurrentAccount.ID,
await fileSecurity.ShareAsync(entry.ID, entryType, AuthContext.CurrentAccount.ID,
entry.RootFolderType == FolderType.USER
? fileSecurity.DefaultMyShare
: fileSecurity.DefaultPrivacyShare);
@ -369,7 +342,7 @@ namespace ASC.Web.Files.Utils
if (g.ID == Constants.LostGroupInfo.ID)
{
fileSecurity.RemoveSubject<T>(r.Subject);
await fileSecurity.RemoveSubjectAsync<T>(r.Subject);
continue;
}
}