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

fix in @my

Browse Source
This commit is contained in:
Nikita 2022-05-26 13:24:12 +03:00
parent 4a0e61de7c
commit 52e2925c8f
5 changed files with 60 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -99,12 +99,12 @@ public class AbstractDao
return set.AsQueryable().Where(r => r.TenantId == tenantId); return set.AsQueryable().Where(r => r.TenantId == tenantId);
} }
protected internal IQueryable<DbFile> GetFileQuery(Expression<Func<DbFile, bool>> where) protected internal IQueryable<DbFile> GetFileQuery(Expression<Func<DbFile, bool>> where, FilesDbContext filesDbContext = null)
{ {
using var FilesDbContext = DbContextManager.GetNew(FileConstant.DatabaseId); var query = Query(filesDbContext.Files)
return Query(FilesDbContext.Files)
.Where(where); .Where(where);
return query;
} }
protected async Task GetRecalculateFilesCountUpdateAsync(int folderId) protected async Task GetRecalculateFilesCountUpdateAsync(int folderId)

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

@ -131,8 +131,7 @@ internal class FileDao : AbstractDao, IFileDao<int>
private async Task<File<int>> InternalGetFileAsync(int parentId, string title) private async Task<File<int>> InternalGetFileAsync(int parentId, string title)
{ {
var query = GetFileQuery(r => r.Title == title && r.CurrentVersion && r.ParentId == parentId) var query = GetFileQuery(r => r.Title == title && r.CurrentVersion && r.ParentId == parentId).AsNoTracking()
.AsNoTracking()
.OrderBy(r => r.CreateOn); .OrderBy(r => r.CreateOn);
var dbFile = await FromQueryWithShared(query).FirstOrDefaultAsync().ConfigureAwait(false); var dbFile = await FromQueryWithShared(query).FirstOrDefaultAsync().ConfigureAwait(false);
@ -142,8 +141,7 @@ internal class FileDao : AbstractDao, IFileDao<int>
public async Task<File<int>> GetFileStableAsync(int fileId, int fileVersion = -1) public async Task<File<int>> GetFileStableAsync(int fileId, int fileVersion = -1)
{ {
var query = GetFileQuery(r => r.Id == fileId && r.Forcesave == ForcesaveType.None) var query = GetFileQuery(r => r.Id == fileId && r.Forcesave == ForcesaveType.None).AsNoTracking();
.AsNoTracking();
if (fileVersion >= 0) if (fileVersion >= 0)
{ {
@ -172,8 +170,7 @@ internal class FileDao : AbstractDao, IFileDao<int>
return AsyncEnumerable.Empty<File<int>>(); return AsyncEnumerable.Empty<File<int>>();
} }
var query = GetFileQuery(r => fileIds.Contains(r.Id) && r.CurrentVersion) var query = GetFileQuery(r => fileIds.Contains(r.Id) && r.CurrentVersion).AsNoTracking();
.AsNoTracking();
return FromQueryWithShared(query).AsAsyncEnumerable() return FromQueryWithShared(query).AsAsyncEnumerable()
.Select(e => _mapper.Map<DbFileQuery, File<int>>(e)); .Select(e => _mapper.Map<DbFileQuery, File<int>>(e));
@ -251,7 +248,6 @@ internal class FileDao : AbstractDao, IFileDao<int>
public IAsyncEnumerable<File<int>> GetFilesAsync(int parentId, OrderBy orderBy, FilterType filterType, bool subjectGroup, Guid subjectID, string searchText, bool searchInContent, bool withSubfolders = false) public IAsyncEnumerable<File<int>> GetFilesAsync(int parentId, OrderBy orderBy, FilterType filterType, bool subjectGroup, Guid subjectID, string searchText, bool searchInContent, bool withSubfolders = false)
{ {
using var FilesDbContext = DbContextManager.GetNew(FileConstant.DatabaseId);
if (filterType == FilterType.FoldersOnly) if (filterType == FilterType.FoldersOnly)
{ {
@ -263,14 +259,16 @@ internal class FileDao : AbstractDao, IFileDao<int>
orderBy = new OrderBy(SortedByType.DateAndTime, false); orderBy = new OrderBy(SortedByType.DateAndTime, false);
} }
var q = GetFileQuery(r => r.ParentId == parentId && r.CurrentVersion).AsNoTracking(); var filesDbContext = DbContextManager.GetNew(FileConstant.DatabaseId);
var q = GetFileQuery(r => r.ParentId == parentId && r.CurrentVersion, filesDbContext).AsNoTracking();
if (withSubfolders) if (withSubfolders)
{ {
q = GetFileQuery(r => r.CurrentVersion) q= GetFileQuery(r => r.CurrentVersion, filesDbContext)
.AsNoTracking() .AsNoTracking()
.Join(FilesDbContext.Tree, r => r.ParentId, a => a.FolderId, (file, tree) => new { file, tree }) .Join(filesDbContext.Tree, r => r.ParentId, a => a.FolderId, (file, tree) => new { file, tree })
.Where(r => r.tree.ParentId == parentId) .Where(r => r.tree.ParentId == parentId)
.Select(r => r.file); .Select(r => r.file);
} }
@ -331,7 +329,7 @@ internal class FileDao : AbstractDao, IFileDao<int>
break; break;
} }
return FromQueryWithShared(q).AsAsyncEnumerable() return FromQueryWithShared(q, filesDbContext).AsAsyncEnumerable()
.Select(_mapper.Map<DbFileQuery, File<int>>); .Select(_mapper.Map<DbFileQuery, File<int>>);
} }
@ -1550,19 +1548,17 @@ internal class FileDao : AbstractDao, IFileDao<int>
}; };
} }
protected IQueryable<DbFileQuery> FromQueryWithShared(IQueryable<DbFile> dbFiles) protected IQueryable<DbFileQuery> FromQueryWithShared(IQueryable<DbFile> dbFiles, FilesDbContext filesDbContext = null)
{ {
var cId = _authContext.CurrentAccount.ID; var cId = _authContext.CurrentAccount.ID;
using var FilesDbContext = DbContextManager.GetNew(FileConstant.DatabaseId);
return from r in dbFiles return from r in dbFiles
select new DbFileQuery select new DbFileQuery
{ {
File = r, File = r,
Root = (from f in FilesDbContext.Folders.AsQueryable() Root = (from f in filesDbContext.Folders.AsQueryable()
where f.Id == where f.Id ==
(from t in FilesDbContext.Tree.AsQueryable() (from t in filesDbContext.Tree.AsQueryable()
where t.FolderId == r.ParentId where t.FolderId == r.ParentId
orderby t.Level descending orderby t.Level descending
select t.ParentId select t.ParentId
@ -1570,11 +1566,11 @@ internal class FileDao : AbstractDao, IFileDao<int>
where f.TenantId == r.TenantId where f.TenantId == r.TenantId
select f select f
).FirstOrDefault(), ).FirstOrDefault(),
Shared = (from f in FilesDbContext.Security.AsQueryable() Shared = (from f in filesDbContext.Security.AsQueryable()
where f.EntryType == FileEntryType.File && f.EntryId == r.Id.ToString() && f.TenantId == r.TenantId where f.EntryType == FileEntryType.File && f.EntryId == r.Id.ToString() && f.TenantId == r.TenantId
select f select f
).Any(), ).Any(),
IsFillFormDraft = (from f in FilesDbContext.FilesLink IsFillFormDraft = (from f in filesDbContext.FilesLink
where f.TenantId == r.TenantId && f.LinkedId == r.Id.ToString() && f.LinkedFor == cId where f.TenantId == r.TenantId && f.LinkedId == r.Id.ToString() && f.LinkedFor == cId
select f) select f)
.Any() .Any()
@ -1585,7 +1581,7 @@ internal class FileDao : AbstractDao, IFileDao<int>
{ {
var cId = _authContext.CurrentAccount.ID; var cId = _authContext.CurrentAccount.ID;
using var FilesDbContext = DbContextManager.GetNew(FileConstant.DatabaseId); var FilesDbContext = DbContextManager.GetNew(FileConstant.DatabaseId);
return dbFiles return dbFiles
.Select(r => new DbFileQuery .Select(r => new DbFileQuery

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

@ -91,9 +91,11 @@ internal class FolderDao : AbstractDao, IFolderDao<int>
public async Task<Folder<int>> GetFolderAsync(int folderId) public async Task<Folder<int>> GetFolderAsync(int folderId)
{ {
var query = GetFolderQuery(r => r.Id == folderId).AsNoTracking(); using var filesDbContext = DbContextManager.GetNew(FileConstant.DatabaseId);
var dbFolder = await FromQueryWithShared(query).Take(1).SingleOrDefaultAsync().ConfigureAwait(false); var query = GetFolderQuery(r => r.Id == folderId, filesDbContext).AsNoTracking();
var dbFolder = await FromQueryWithShared(query, filesDbContext).Take(1).SingleOrDefaultAsync().ConfigureAwait(false);
return _mapper.Map<DbFolderQuery, Folder<int>>(dbFolder); return _mapper.Map<DbFolderQuery, Folder<int>>(dbFolder);
} }
@ -176,13 +178,13 @@ internal class FolderDao : AbstractDao, IFolderDao<int>
orderBy = new OrderBy(SortedByType.DateAndTime, false); orderBy = new OrderBy(SortedByType.DateAndTime, false);
} }
var q = GetFolderQuery(r => r.ParentId == parentId).AsNoTracking(); var filesDbContext = DbContextManager.GetNew(FileConstant.DatabaseId);
using var FilesDbContext = DbContextManager.GetNew(FileConstant.DatabaseId); var q = GetFolderQuery(r => r.ParentId == parentId, filesDbContext).AsNoTracking();
if (withSubfolders) if (withSubfolders)
{ {
q = GetFolderQuery().AsNoTracking() q = GetFolderQuery(null, filesDbContext).AsNoTracking()
.Join(FilesDbContext.Tree, r => r.Id, a => a.FolderId, (folder, tree) => new { folder, tree }) .Join(FilesDbContext.Tree, r => r.Id, a => a.FolderId, (folder, tree) => new { folder, tree })
.Where(r => r.tree.ParentId == parentId && r.tree.Level != 0) .Where(r => r.tree.ParentId == parentId && r.tree.Level != 0)
.Select(r => r.folder); .Select(r => r.folder);
@ -221,7 +223,7 @@ internal class FolderDao : AbstractDao, IFolderDao<int>
} }
} }
var dbFolders = FromQueryWithShared(q).AsAsyncEnumerable(); var dbFolders = FromQueryWithShared(q, filesDbContext).AsAsyncEnumerable();
return dbFolders.Select(_mapper.Map<DbFolderQuery, Folder<int>>); return dbFolders.Select(_mapper.Map<DbFolderQuery, Folder<int>>);
} }
@ -236,13 +238,13 @@ internal class FolderDao : AbstractDao, IFolderDao<int>
return AsyncEnumerable.Empty<Folder<int>>(); return AsyncEnumerable.Empty<Folder<int>>();
} }
var q = GetFolderQuery(r => folderIds.Contains(r.Id)).AsNoTracking(); var FilesDbContext = DbContextManager.GetNew(FileConstant.DatabaseId);
using var FilesDbContext = DbContextManager.GetNew(FileConstant.DatabaseId); var q = GetFolderQuery(r => folderIds.Contains(r.Id), FilesDbContext).AsNoTracking();
if (searchSubfolders) if (searchSubfolders)
{ {
q = GetFolderQuery() q = GetFolderQuery(null, FilesDbContext)
.AsNoTracking() .AsNoTracking()
.Join(FilesDbContext.Tree, r => r.Id, a => a.FolderId, (folder, tree) => new { folder, tree }) .Join(FilesDbContext.Tree, r => r.Id, a => a.FolderId, (folder, tree) => new { folder, tree })
.Where(r => folderIds.Contains(r.tree.ParentId)) .Where(r => folderIds.Contains(r.tree.ParentId))
@ -279,23 +281,23 @@ internal class FolderDao : AbstractDao, IFolderDao<int>
} }
} }
var dbFolders = (checkShare ? FromQueryWithShared(q) : FromQuery(q)).AsAsyncEnumerable(); var dbFolders = (checkShare ? FromQueryWithShared(q, FilesDbContext) : FromQuery(q, FilesDbContext)).AsAsyncEnumerable();
return dbFolders.Select(_mapper.Map<DbFolderQuery, Folder<int>>).Distinct(); return dbFolders.Select(_mapper.Map<DbFolderQuery, Folder<int>>).Distinct();
} }
public async Task<List<Folder<int>>> GetParentFoldersAsync(int folderId) public async Task<List<Folder<int>>> GetParentFoldersAsync(int folderId)
{ {
using var FilesDbContext = DbContextManager.GetNew(FileConstant.DatabaseId); using var filesDbContext = DbContextManager.GetNew(FileConstant.DatabaseId);
var q = GetFolderQuery() var q = GetFolderQuery(null, filesDbContext)
.AsNoTracking() .AsNoTracking()
.Join(FilesDbContext.Tree, r => r.Id, a => a.ParentId, (folder, tree) => new { folder, tree }) .Join(filesDbContext.Tree, r => r.Id, a => a.ParentId, (folder, tree) => new { folder, tree })
.Where(r => r.tree.FolderId == folderId) .Where(r => r.tree.FolderId == folderId)
.OrderByDescending(r => r.tree.Level) .OrderByDescending(r => r.tree.Level)
.Select(r => r.folder); .Select(r => r.folder);
var query = await FromQueryWithShared(q).ToListAsync().ConfigureAwait(false); var query = await FromQueryWithShared(q, filesDbContext).ToListAsync().ConfigureAwait(false);
return _mapper.Map<List<DbFolderQuery>, List<Folder<int>>>(query); return _mapper.Map<List<DbFolderQuery>, List<Folder<int>>>(query);
} }
@ -1161,11 +1163,9 @@ internal class FolderDao : AbstractDao, IFolderDao<int>
#endregion #endregion
protected internal IQueryable<DbFolder> GetFolderQuery(Expression<Func<DbFolder, bool>> where = null) protected internal IQueryable<DbFolder> GetFolderQuery(Expression<Func<DbFolder, bool>> where = null, FilesDbContext filesDbContext = null)
{ {
using var FilesDbContext = DbContextManager.GetNew(FileConstant.DatabaseId); var q = Query(filesDbContext.Folders);
var q = Query(FilesDbContext.Folders);
if (where != null) if (where != null)
{ {
q = q.Where(where); q = q.Where(where);
@ -1174,9 +1174,9 @@ internal class FolderDao : AbstractDao, IFolderDao<int>
return q; return q;
} }
protected IQueryable<DbFolderQuery> FromQueryWithShared(IQueryable<DbFolder> dbFiles) protected IQueryable<DbFolderQuery> FromQueryWithShared(IQueryable<DbFolder> dbFiles, FilesDbContext filesDbContext = null)
{ {
using var FilesDbContext = DbContextManager.GetNew(FileConstant.DatabaseId); var FilesDbContext = filesDbContext ?? base.FilesDbContext;
var e = from r in dbFiles var e = from r in dbFiles
select new DbFolderQuery select new DbFolderQuery
@ -1201,9 +1201,9 @@ internal class FolderDao : AbstractDao, IFolderDao<int>
return e; return e;
} }
protected IQueryable<DbFolderQuery> FromQuery(IQueryable<DbFolder> dbFiles) protected IQueryable<DbFolderQuery> FromQuery(IQueryable<DbFolder> dbFiles, FilesDbContext filesDbContext = null)
{ {
using var FilesDbContext = DbContextManager.GetNew(FileConstant.DatabaseId); var FilesDbContext = filesDbContext;
return dbFiles return dbFiles
.Select(r => new DbFolderQuery .Select(r => new DbFolderQuery

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

@ -389,7 +389,7 @@ internal class SecurityDao<T> : AbstractDao, ISecurityDao<T>
private IQueryable<DbFilesSecurity> GetQuery(Expression<Func<DbFilesSecurity, bool>> where = null) private IQueryable<DbFilesSecurity> GetQuery(Expression<Func<DbFilesSecurity, bool>> where = null)
{ {
using var FilesDbContext = DbContextManager.GetNew(FileConstant.DatabaseId); var FilesDbContext = DbContextManager.GetNew(FileConstant.DatabaseId);
var q = Query(FilesDbContext.Security); var q = Query(FilesDbContext.Security);
if (q != null) if (q != null)

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

@ -497,11 +497,14 @@ public class EntryManager
{ {
var folderDao = _daoFactory.GetFolderDao<T>(); var folderDao = _daoFactory.GetFolderDao<T>();
var fileDao = _daoFactory.GetFileDao<T>(); var fileDao = _daoFactory.GetFileDao<T>();
var folders = await folderDao.GetFoldersAsync(parent.Id, orderBy, filter, subjectGroup, subjectId, searchText, withSubfolders).ToListAsync();
entries = entries.Concat(await fileSecurity.FilterReadAsync(folders));
var files = await fileDao.GetFilesAsync(parent.Id, orderBy, filter, subjectGroup, subjectId, searchText, searchInContent, withSubfolders).ToListAsync(); var folders = folderDao.GetFoldersAsync(parent.Id, orderBy, filter, subjectGroup, subjectId, searchText, withSubfolders).ToListAsync();
entries = entries.Concat(await fileSecurity.FilterReadAsync(files));
entries = entries.Concat(await fileSecurity.FilterReadAsync(await folders));
var files = fileDao.GetFilesAsync(parent.Id, orderBy, filter, subjectGroup, subjectId, searchText, searchInContent, withSubfolders).ToListAsync();
entries = entries.Concat(await fileSecurity.FilterReadAsync(await files));
//share //share
var shared = await fileSecurity.GetPrivacyForMeAsync(filter, subjectGroup, subjectId, searchText, searchInContent, withSubfolders); var shared = await fileSecurity.GetPrivacyForMeAsync(filter, subjectGroup, subjectId, searchText, searchInContent, withSubfolders);
@ -517,11 +520,13 @@ public class EntryManager
withSubfolders = false; withSubfolders = false;
} }
var folders = await _daoFactory.GetFolderDao<T>().GetFoldersAsync(parent.Id, orderBy, filter, subjectGroup, subjectId, searchText, withSubfolders).ToListAsync(); var files = _daoFactory.GetFileDao<T>().GetFilesAsync(parent.Id, orderBy, filter, subjectGroup, subjectId, searchText, searchInContent, withSubfolders).ToListAsync();
entries = entries.Concat(await fileSecurity.FilterReadAsync(folders)); var folders = _daoFactory.GetFolderDao<T>().GetFoldersAsync(parent.Id, orderBy, filter, subjectGroup, subjectId, searchText, withSubfolders).ToListAsync();
entries = entries.Concat(await fileSecurity.FilterReadAsync(await files));
entries = entries.Concat(await fileSecurity.FilterReadAsync(await folders));
var files = await _daoFactory.GetFileDao<T>().GetFilesAsync(parent.Id, orderBy, filter, subjectGroup, subjectId, searchText, searchInContent, withSubfolders).ToListAsync();
entries = entries.Concat(await fileSecurity.FilterReadAsync(files));
if (filter == FilterType.None || filter == FilterType.FoldersOnly) if (filter == FilterType.None || filter == FilterType.FoldersOnly)
{ {