Files: template methods

products/ASC.Files/Server/Controllers/FilesController.cs

@@ -767,7 +767,7 @@ namespace ASC.Api.Documents
         [Create("{folderId}/file")]
         public FileWrapper CreateFile(string folderId, string title)
         {
-            var file = FileStorageService.CreateNewFile(new FileModel { ParentId = folderId, Title = title });
+            var file = FileStorageService.CreateNewFile<string>(new FileModel<string> { ParentId = folderId, Title = title });
             return FileWrapperHelper.Get(file);
         }
 
@@ -907,7 +907,7 @@ namespace ASC.Api.Documents
         [Read("file/{fileId}/checkconversion")]
         public IEnumerable<ConversationResult> CheckConversion(string fileId, bool start)
         {
-            return FileStorageService.CheckConversion(new ItemList<ItemList<string>>
+            return FileStorageService.CheckConversion<string>(new ItemList<ItemList<string>>
             {
                 new ItemList<string> { fileId, "0", start.ToString() }
             })
@@ -971,7 +971,7 @@ namespace ASC.Api.Documents
 
             var ids = FileStorageService.MoveOrCopyFilesCheck(itemList, batchModel.DestFolderId).Keys.Select(id => "file_" + id);
 
-            var entries = FileStorageService.GetItems(new ItemList<string>(ids), FilterType.FilesOnly, false, "", "");
+            var entries = FileStorageService.GetItems<string>(new ItemList<string>(ids), FilterType.FilesOnly, false, "", "");
             return entries.Select(x => FileWrapperHelper.Get((Files.Core.File)x));
         }
 
@@ -994,7 +994,7 @@ namespace ASC.Api.Documents
             itemList.AddRange((batchModel.FolderIds ?? new List<string>()).Select(x => "folder_" + x));
             itemList.AddRange((batchModel.FileIds ?? new List<string>()).Select(x => "file_" + x));
 
-            return FileStorageService.MoveOrCopyItems(itemList, batchModel.DestFolderId, batchModel.ConflictResolveType, false, batchModel.DeleteAfter).Select(FileOperationWraperHelper.Get);
+            return FileStorageService.MoveOrCopyItems<string>(itemList, batchModel.DestFolderId, batchModel.ConflictResolveType, false, batchModel.DeleteAfter).Select(FileOperationWraperHelper.Get);
         }
 
         /// <summary>
@@ -1016,7 +1016,7 @@ namespace ASC.Api.Documents
             itemList.AddRange((batchModel.FolderIds ?? new List<string>()).Select(x => "folder_" + x));
             itemList.AddRange((batchModel.FileIds ?? new List<string>()).Select(x => "file_" + x));
 
-            return FileStorageService.MoveOrCopyItems(itemList, batchModel.DestFolderId, batchModel.ConflictResolveType, true, batchModel.DeleteAfter).Select(FileOperationWraperHelper.Get);
+            return FileStorageService.MoveOrCopyItems<string>(itemList, batchModel.DestFolderId, batchModel.ConflictResolveType, true, batchModel.DeleteAfter).Select(FileOperationWraperHelper.Get);
         }
 
         /// <summary>
@@ -1033,7 +1033,7 @@ namespace ASC.Api.Documents
             itemList.AddRange((model.FolderIds ?? new List<string>()).Select(x => "folder_" + x));
             itemList.AddRange((model.FileIds ?? new List<string>()).Select(x => "file_" + x));
 
-            return FileStorageService.MarkAsRead(itemList).Select(FileOperationWraperHelper.Get);
+            return FileStorageService.MarkAsRead<string>(itemList).Select(FileOperationWraperHelper.Get);
         }
 
         /// <summary>
@@ -1111,7 +1111,7 @@ namespace ASC.Api.Documents
             itemList.AddRange((batch.FolderIds ?? new List<string>()).Select(x => "folder_" + x));
             itemList.AddRange((batch.FileIds ?? new List<string>()).Select(x => "file_" + x));
 
-            return FileStorageService.DeleteItems("delete", itemList, false, batch.DeleteAfter, batch.Immediately).Select(FileOperationWraperHelper.Get);
+            return FileStorageService.DeleteItems<string>("delete", itemList, false, batch.DeleteAfter, batch.Immediately).Select(FileOperationWraperHelper.Get);
         }
 
         /// <summary>
@@ -1123,7 +1123,7 @@ namespace ASC.Api.Documents
         [Update("fileops/emptytrash")]
         public IEnumerable<FileOperationWraper> EmptyTrash()
         {
-            return FileStorageService.EmptyTrash().Select(FileOperationWraperHelper.Get);
+            return FileStorageService.EmptyTrash<int>().Select(FileOperationWraperHelper.Get);
         }
 
         /// <summary>
@@ -1208,7 +1208,7 @@ namespace ASC.Api.Documents
                     Aces = list,
                     Message = sharingMessage
                 };
-                FileStorageService.SetAceObject(aceCollection, notify);
+                FileStorageService.SetAceObject<string>(aceCollection, notify);
             }
             return GetFileSecurityInfo(fileId);
         }
@@ -1238,7 +1238,7 @@ namespace ASC.Api.Documents
                     Aces = list,
                     Message = sharingMessage
                 };
-                FileStorageService.SetAceObject(aceCollection, notify);
+                FileStorageService.SetAceObject<string>(aceCollection, notify);
             }
 
             return GetFolderSecurityInfo(folderId);
@@ -1260,7 +1260,7 @@ namespace ASC.Api.Documents
             itemList.AddRange((model.FolderIds ?? new List<string>()).Select(x => "folder_" + x));
             itemList.AddRange((model.FileIds ?? new List<string>()).Select(x => "file_" + x));
 
-            FileStorageService.RemoveAce(itemList);
+            FileStorageService.RemoveAce<string>(itemList);
 
             return true;
         }
@@ -1298,7 +1298,7 @@ namespace ASC.Api.Documents
                     Entries = new ItemList<string> { objectId },
                     Aces = list
                 };
-                FileStorageService.SetAceObject(aceCollection, false);
+                FileStorageService.SetAceObject<string>(aceCollection, false);
                 sharedInfo = FileStorageService.GetSharedInfo(new ItemList<string> { objectId }).Find(r => r.SubjectId == FileConstant.ShareLinkId);
             }
 
@@ -1548,11 +1548,13 @@ namespace ASC.Api.Documents
 
         private FolderContentWrapper ToFolderContentWrapper(object folderId, Guid userIdOrGroupId, FilterType filterType)
         {
-            SortedByType sortBy;
-            if (!Enum.TryParse(ApiContext.SortBy, true, out sortBy))
+            if (!Enum.TryParse(ApiContext.SortBy, true, out SortedByType sortBy))
+            {
                 sortBy = SortedByType.AZ;
+            }
+
             var startIndex = Convert.ToInt32(ApiContext.StartIndex);
-            return FolderContentWrapperHelper.Get(FileStorageService.GetFolderItems(folderId.ToString(),
+            return FolderContentWrapperHelper.Get(FileStorageService.GetFolderItems<string>(folderId.ToString(),
                                                                                startIndex,
                                                                                Convert.ToInt32(ApiContext.Count) - 1, //NOTE: in ApiContext +1
                                                                                filterType,

products/ASC.Files/Server/Core/Dao/Interfaces/IDaoFactory.cs

@@ -32,8 +32,12 @@ namespace ASC.Files.Core
     {
         IFolderDao FolderDao { get; }
 
+        IFolderDao<T> GetFolderDao<T>();
+
         IFileDao FileDao { get; }
 
+        IFileDao<T> GetFileDao<T>();
+
         ITagDao TagDao { get; }
 
         ISecurityDao SecurityDao { get; }

products/ASC.Files/Server/Core/Dao/Interfaces/IFileDao.cs

@@ -103,7 +103,7 @@ namespace ASC.Files.Core
         /// </summary>
         /// <param name="parentId"></param>
         /// <returns></returns>
-        List<object> GetFiles(T parentId);
+        List<T> GetFiles(T parentId);
 
         /// <summary>
         ///     Get files in folder
@@ -188,14 +188,14 @@ namespace ASC.Files.Core
         /// <param name="title">file name</param>
         /// <param name="folderId">folder id</param>
         /// <returns>Returns true if the file exists, otherwise false</returns>
-        bool IsExist(string title, T folderId);
+        bool IsExist(string title, object folderId);
 
         /// <summary>
         ///   Moves a file or set of files in a folder
         /// </summary>
         /// <param name="fileId">file id</param>
         /// <param name="toFolderId">The ID of the destination folder</param>
-        object MoveFile(T fileId, T toFolderId);
+        T MoveFile(T fileId, T toFolderId);
 
         /// <summary>
         ///  Copy the files in a folder
@@ -209,7 +209,7 @@ namespace ASC.Files.Core
         /// </summary>
         /// <param name="file"></param>
         /// <param name="newTitle">new name</param>
-        object FileRename(File<T> file, string newTitle);
+        T FileRename(File<T> file, string newTitle);
 
         /// <summary>
         ///   Update comment file
@@ -240,9 +240,15 @@ namespace ASC.Files.Core
         /// <returns></returns>
         bool UseTrashForRemove(File<T> file);
 
+        string GetUniqFilePath(File<T> file, string fileTitle);
+
         #region chunking
 
-        ChunkedUploadSession CreateUploadSession(File<T> file, long contentLength);
+        ChunkedUploadSession<T> CreateUploadSession(File<T> file, long contentLength);
+
+        void UploadChunk(ChunkedUploadSession<T> uploadSession, Stream chunkStream, long chunkLength);
+
+        void AbortUploadSession(ChunkedUploadSession<T> uploadSession);
 
         #endregion
 
@@ -507,11 +513,11 @@ namespace ASC.Files.Core
 
         #region chunking
 
-        ChunkedUploadSession CreateUploadSession(File file, long contentLength);
+        ChunkedUploadSession<object> CreateUploadSession(File file, long contentLength);
 
-        void UploadChunk(ChunkedUploadSession uploadSession, Stream chunkStream, long chunkLength);
+        void UploadChunk(ChunkedUploadSession<object> uploadSession, Stream chunkStream, long chunkLength);
 
-        void AbortUploadSession(ChunkedUploadSession uploadSession);
+        void AbortUploadSession(ChunkedUploadSession<object> uploadSession);
 
         #endregion
 

products/ASC.Files/Server/Core/Dao/Interfaces/IFolderDao.cs

@@ -30,6 +30,259 @@ using System.Threading;
 
 namespace ASC.Files.Core
 {
+    public interface IFolderDao<T>
+    {
+        /// <summary>
+        ///     Get folder by id.
+        /// </summary>
+        /// <param name="folderId">folder id</param>
+        /// <returns>folder</returns>
+        Folder<T> GetFolder(T folderId);
+
+        /// <summary>
+        ///     Returns the folder with the given name and id of the root
+        /// </summary>
+        /// <param name="title"></param>
+        /// <param name="parentId"></param>
+        /// <returns></returns>
+        Folder<T> GetFolder(string title, T parentId);
+
+        /// <summary>
+        ///    Gets the root folder
+        /// </summary>
+        /// <param name="folderId">folder id</param>
+        /// <returns>root folder</returns>
+        Folder<T> GetRootFolder(T folderId);
+
+        /// <summary>
+        ///    Gets the root folder
+        /// </summary>
+        /// <param name="fileId">file id</param>
+        /// <returns>root folder</returns>
+        Folder<T> GetRootFolderByFile(T fileId);
+
+        /// <summary>
+        ///     Get a list of folders in current folder.
+        /// </summary>
+        /// <param name="parentId"></param>
+        List<Folder<T>> GetFolders(T parentId);
+
+        /// <summary>
+        /// Get a list of folders.
+        /// </summary>
+        /// <param name="parentId"></param>
+        /// <param name="orderBy"></param>
+        /// <param name="filterType"></param>
+        /// <param name="subjectGroup"></param>
+        /// <param name="subjectID"></param>
+        /// <param name="searchText"></param>
+        /// <param name="withSubfolders"></param>
+        /// <returns></returns>
+        List<Folder<T>> GetFolders(T parentId, OrderBy orderBy, FilterType filterType, bool subjectGroup, Guid subjectID, string searchText, bool withSubfolders = false);
+
+        /// <summary>
+        /// Gets the folder (s) by ID (s)
+        /// </summary>
+        /// <param name="folderIds"></param>
+        /// <param name="filterType"></param>
+        /// <param name="subjectGroup"></param>
+        /// <param name="subjectID"></param>
+        /// <param name="searchText"></param>
+        /// <param name="searchSubfolders"></param>
+        /// <param name="checkShare"></param>
+        /// <returns></returns>
+        List<Folder<T>> GetFolders(T[] folderIds, FilterType filterType = FilterType.None, bool subjectGroup = false, Guid? subjectID = null, string searchText = "", bool searchSubfolders = false, bool checkShare = true);
+
+        /// <summary>
+        ///     Get folder, contains folder with id
+        /// </summary>
+        /// <param name="folderId">folder id</param>
+        /// <returns></returns>
+        List<Folder<T>> GetParentFolders(T folderId);
+
+        /// <summary>
+        ///     save or update folder
+        /// </summary>
+        /// <param name="folder"></param>
+        /// <returns></returns>
+        T SaveFolder(Folder<T> folder);
+
+        /// <summary>
+        ///     delete folder
+        /// </summary>
+        /// <param name="folderId">folder id</param>
+        void DeleteFolder(T folderId);
+
+        /// <summary>
+        ///  move folder
+        /// </summary>
+        /// <param name="folderId">folder id</param>
+        /// <param name="toFolderId">destination folder id</param>
+        /// <param name="cancellationToken"></param>
+        T MoveFolder(T folderId, T toFolderId, CancellationToken? cancellationToken);
+
+        /// <summary>
+        ///     copy folder
+        /// </summary>
+        /// <param name="folderId"></param>
+        /// <param name="toFolderId"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns> 
+        /// </returns>
+        Folder<T> CopyFolder(T folderId, T toFolderId, CancellationToken? cancellationToken);
+
+        /// <summary>
+        /// Validate the transfer operation directory to another directory.
+        /// </summary>
+        /// <param name="folderIds"></param>
+        /// <param name="to"></param>
+        /// <returns>
+        /// Returns pair of file ID, file name, in which the same name.
+        /// </returns>
+        IDictionary<T, string> CanMoveOrCopy(T[] folderIds, T to);
+
+        /// <summary>
+        ///     Rename folder
+        /// </summary>
+        /// <param name="folder"></param>
+        /// <param name="newTitle">new name</param>
+        T RenameFolder(Folder<T> folder, string newTitle);
+
+        /// <summary>
+        ///    Gets the number of files and folders to the container in your
+        /// </summary>
+        /// <param name="folderId">folder id</param>
+        /// <returns></returns>
+        int GetItemsCount(T folderId);
+
+        /// <summary>
+        ///    Check folder on emptiness
+        /// </summary>
+        /// <param name="folderId">folder id</param>
+        /// <returns></returns>
+        bool IsEmpty(T folderId);
+
+        /// <summary>
+        /// Check the need to use the trash before removing
+        /// </summary>
+        /// <param name="folder"></param>
+        /// <returns></returns>
+        bool UseTrashForRemove(Folder<T> folder);
+
+        /// <summary>
+        /// Check the need to use recursion for operations
+        /// </summary>
+        /// <param name="folderId"> </param>
+        /// <param name="toRootFolderId"> </param>
+        /// <returns></returns>
+        bool UseRecursiveOperation(T folderId, T toRootFolderId);
+
+        /// <summary>
+        /// Check the possibility to calculate the number of subitems
+        /// </summary>
+        /// <param name="entryId"> </param>
+        /// <returns></returns>
+        bool CanCalculateSubitems(T entryId);
+
+        /// <summary>
+        /// Returns maximum size of file which can be uploaded to specific folder
+        /// </summary>
+        /// <param name="folderId">Id of the folder</param>
+        /// <param name="chunkedUpload">Determines whenever supposed upload will be chunked (true) or not (false)</param>
+        /// <returns>Maximum size of file which can be uploaded to folder</returns>
+        long GetMaxUploadSize(T folderId, bool chunkedUpload = false);
+
+        #region Only for TMFolderDao
+
+        /// <summary>
+        /// Set created by
+        /// </summary>
+        /// <param name="folderIds"></param>
+        /// <param name="newOwnerId"></param>
+        void ReassignFolders(T[] folderIds, Guid newOwnerId);
+
+        /// <summary>
+        /// Search the list of folders containing text in title
+        /// Only in TMFolderDao
+        /// </summary>
+        /// <param name="text"></param>
+        /// <param name="bunch"></param>
+        /// <returns></returns>
+        IEnumerable<Folder<T>> Search(string text, bool bunch = false);
+
+        /// <summary>
+        /// Only in TMFolderDao
+        /// </summary>
+        /// <param name="module"></param>
+        /// <param name="bunch"></param>
+        /// <param name="data"></param>
+        /// <param name="createIfNotExists"></param>
+        /// <returns></returns>
+        T GetFolderID(string module, string bunch, Guid data, bool createIfNotExists);
+
+        IEnumerable<T> GetFolderIDs(string module, string bunch, IEnumerable<T> data, bool createIfNotExists);
+
+        /// <summary>
+        ///  Returns id folder "Shared Documents"
+        /// Only in TMFolderDao
+        /// </summary>
+        /// <returns></returns>
+        T GetFolderIDCommon(bool createIfNotExists);
+
+        /// <summary>
+        ///  Returns id folder "My Documents"
+        /// Only in TMFolderDao
+        /// </summary>
+        /// <param name="createIfNotExists"></param>
+        /// <param name="userId"></param>
+        /// <returns></returns>
+        T GetFolderIDUser(bool createIfNotExists, Guid? userId = null);
+
+        /// <summary>
+        /// Returns id folder "Shared with me"
+        /// Only in TMFolderDao
+        /// </summary>
+        /// <param name="createIfNotExists"></param>
+        /// <returns></returns>
+        T GetFolderIDShare(bool createIfNotExists);
+
+        /// <summary>
+        /// Returns id folder "Trash"
+        /// Only in TMFolderDao
+        /// </summary>
+        /// <param name="createIfNotExists"></param>
+        /// <param name="userId"></param>
+        /// <returns></returns>
+        T GetFolderIDTrash(bool createIfNotExists, Guid? userId = null);
+
+        /// <summary>
+        /// Returns id folder "Projects"
+        /// Only in TMFolderDao
+        /// </summary>
+        /// <param name="createIfNotExists"></param>
+        /// <returns></returns>
+        T GetFolderIDProjects(bool createIfNotExists);
+
+
+        /// <summary>
+        /// Return id of related object
+        /// Only in TMFolderDao
+        /// </summary>
+        /// <param name="folderID"></param>
+        /// <returns></returns>
+        string GetBunchObjectID(T folderID);
+
+        /// <summary>
+        /// Return ids of related objects
+        /// Only in TMFolderDao
+        /// </summary>
+        /// <param name="folderIDs"></param>
+        /// <returns></returns>
+        Dictionary<string, string> GetBunchObjectIDs(List<T> folderIDs);
+
+        #endregion
+    }
+
     public interface IFolderDao
     {
         /// <summary>

products/ASC.Files/Server/Core/Dao/TeamlabDao/DaoFactory.cs

@@ -24,26 +24,42 @@
 */
 
 
+using System;
+
 using ASC.Common;
 using ASC.Files.Core.Security;
 
+using Microsoft.Extensions.DependencyInjection;
+
 namespace ASC.Files.Core.Data
 {
     public class DaoFactory : IDaoFactory
     {
+        public IServiceProvider ServiceProvider { get; }
         public IFileDao FileDao { get; }
         public IFolderDao FolderDao { get; }
         public ITagDao TagDao { get; }
         public ISecurityDao SecurityDao { get; }
         public IProviderDao ProviderDao { get; }
 
-        public DaoFactory(IFileDao fileDao, IFolderDao folderDao, ITagDao tagDao, ISecurityDao securityDao)
+        public DaoFactory(IServiceProvider serviceProvider, IFileDao fileDao, IFolderDao folderDao, ITagDao tagDao, ISecurityDao securityDao)
         {
+            ServiceProvider = serviceProvider;
             FileDao = fileDao;
             FolderDao = folderDao;
             TagDao = tagDao;
             SecurityDao = securityDao;
         }
+
+        public IFileDao<T> GetFileDao<T>()
+        {
+            return ServiceProvider.GetService<IFileDao<T>>();
+        }
+
+        public IFolderDao<T> GetFolderDao<T>()
+        {
+            return ServiceProvider.GetService<IFolderDao<T>>();
+        }
     }
 
     public static class DaoFactoryExtention

products/ASC.Files/Server/Core/Dao/TeamlabDao/FileDao.cs

@@ -104,6 +104,7 @@ namespace ASC.Files.Core.Data
 
         public void InvalidateCache(object fileId)
         {
+            throw new NotImplementedException();
         }
 
         public void InvalidateCache(int fileId)
@@ -112,27 +113,36 @@ namespace ASC.Files.Core.Data
 
         public File GetFile(object fileId)
         {
-            var query = GetFileQuery(r => r.Id.ToString() == fileId.ToString() && r.CurrentVersion);
-            return FromQueryWithShared(query).SingleOrDefault();
+            throw new NotImplementedException();
         }
 
         public File<int> GetFile(int fileId)
         {
             var query = GetFileQuery(r => r.Id == fileId && r.CurrentVersion);
-            return FromQueryWithSharedInt(query).SingleOrDefault();
+            return FromQueryWithShared(query).SingleOrDefault();
         }
 
         public File GetFile(object fileId, int fileVersion)
         {
-            var query = GetFileQuery(r => r.Id.ToString() == fileId.ToString() && r.Version == fileVersion);
+            throw new NotImplementedException();
+        }
+
+        public File<int> GetFile(int fileId, int fileVersion)
+        {
+            var query = GetFileQuery(r => r.Id == fileId && r.Version == fileVersion);
             return FromQueryWithShared(query).SingleOrDefault();
         }
 
         public File GetFile(object parentId, string title)
+        {
+            throw new NotImplementedException();
+        }
+
+        public File<int> GetFile(int parentId, string title)
         {
             if (string.IsNullOrEmpty(title)) throw new ArgumentNullException(title);
 
-            var query = GetFileQuery(r => r.Title == title && r.CurrentVersion == true && r.FolderId.ToString() == parentId.ToString())
+            var query = GetFileQuery(r => r.Title == title && r.CurrentVersion == true && r.FolderId == parentId)
                 .OrderBy(r => r.CreateOn);
 
             return FromQueryWithShared(query).FirstOrDefault();
@@ -140,7 +150,12 @@ namespace ASC.Files.Core.Data
 
         public File GetFileStable(object fileId, int fileVersion = -1)
         {
-            var query = GetFileQuery(r => r.Id.ToString() == fileId.ToString() && r.Forcesave == ForcesaveType.None);
+            throw new NotImplementedException();
+        }
+
+        public File<int> GetFileStable(int fileId, int fileVersion = -1)
+        {
+            var query = GetFileQuery(r => r.Id == fileId && r.Forcesave == ForcesaveType.None);
 
             if (fileVersion >= 0)
             {
@@ -154,26 +169,40 @@ namespace ASC.Files.Core.Data
 
         public List<File> GetFileHistory(object fileId)
         {
-            var query = GetFileQuery(r => r.Id.ToString() == fileId.ToString()).OrderByDescending(r => r.Version);
+            throw new NotImplementedException();
+        }
+
+        public List<File<int>> GetFileHistory(int fileId)
+        {
+            var query = GetFileQuery(r => r.Id == fileId).OrderByDescending(r => r.Version);
 
             return FromQueryWithShared(query);
         }
 
         public List<File> GetFiles(object[] fileIds)
         {
-            if (fileIds == null || fileIds.Length == 0) return new List<File>();
+            throw new NotImplementedException();
+        }
 
-            var query = GetFileQuery(r => fileIds.Any(a => a.ToString() == r.Id.ToString()) && r.CurrentVersion);
+        public List<File<int>> GetFiles(int[] fileIds)
+        {
+            if (fileIds == null || fileIds.Length == 0) return new List<File<int>>();
+
+            var query = GetFileQuery(r => fileIds.Any(a => a == r.Id) && r.CurrentVersion);
 
             return FromQueryWithShared(query);
         }
 
         public List<File> GetFilesForShare(object[] fileIds, FilterType filterType, bool subjectGroup, Guid subjectID, string searchText, bool searchInContent)
         {
-            if (fileIds == null || fileIds.Length == 0 || filterType == FilterType.FoldersOnly) return new List<File>();
+            throw new NotImplementedException();
+        }
 
-            var fileIdsStrings = fileIds.Select(r => r.ToString()).ToList();
-            var query = GetFileQuery(r => fileIdsStrings.Any(a => a == r.Id.ToString()) && r.CurrentVersion);
+        public List<File<int>> GetFilesForShare(int[] fileIds, FilterType filterType, bool subjectGroup, Guid subjectID, string searchText, bool searchInContent)
+        {
+            if (fileIds == null || fileIds.Length == 0 || filterType == FilterType.FoldersOnly) return new List<File<int>>();
+
+            var query = GetFileQuery(r => fileIds.Any(a => a == r.Id) && r.CurrentVersion);
 
             if (!string.IsNullOrEmpty(searchText))
             {
@@ -223,33 +252,41 @@ namespace ASC.Files.Core.Data
             return FromQuery(query);
         }
 
+
         public List<object> GetFiles(object parentId)
         {
-            var parentIdString = parentId.ToString();
-            var query = GetFileQuery(r => r.FolderId.ToString() == parentIdString && r.CurrentVersion).Select(r => r.Id);
+            throw new NotImplementedException();
+        }
+
+        public List<int> GetFiles(int parentId)
+        {
+            var query = GetFileQuery(r => r.FolderId == parentId && r.CurrentVersion).Select(r => r.Id);
 
             return Query(FilesDbContext.Files)
-                .Where(r => r.FolderId.ToString() == parentIdString && r.CurrentVersion)
+                .Where(r => r.FolderId == parentId && r.CurrentVersion)
                 .Select(r => r.Id)
-                .ToList()
-                .ConvertAll(r => (object)r);
+                .ToList();
         }
 
         public List<File> GetFiles(object parentId, OrderBy orderBy, FilterType filterType, bool subjectGroup, Guid subjectID, string searchText, bool searchInContent, bool withSubfolders = false)
         {
-            if (filterType == FilterType.FoldersOnly) return new List<File>();
+            throw new NotImplementedException();
+        }
+
+        public List<File<int>> GetFiles(int parentId, OrderBy orderBy, FilterType filterType, bool subjectGroup, Guid subjectID, string searchText, bool searchInContent, bool withSubfolders = false)
+        {
+            if (filterType == FilterType.FoldersOnly) return new List<File<int>>();
 
             if (orderBy == null) orderBy = new OrderBy(SortedByType.DateAndTime, false);
 
-            var parentIdString = parentId.ToString();
-            var q = GetFileQuery(r => r.FolderId.ToString() == parentIdString && r.CurrentVersion);
+            var q = GetFileQuery(r => r.FolderId == parentId && r.CurrentVersion);
 
 
             if (withSubfolders)
             {
                 q = GetFileQuery(r => r.CurrentVersion)
                     .Join(FilesDbContext.Tree, r => r.FolderId, a => a.FolderId, (file, tree) => new { file, tree })
-                    .Where(r => r.tree.ParentId.ToString() == parentIdString)
+                    .Where(r => r.tree.ParentId == parentId)
                     .Select(r => r.file);
             }
 
@@ -326,11 +363,21 @@ namespace ASC.Files.Core.Data
         }
 
         public Stream GetFileStream(File file, long offset)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Stream GetFileStream(File<int> file, long offset)
         {
             return GlobalStore.GetStore().GetReadStream(string.Empty, GetUniqFilePath(file), (int)offset);
         }
 
         public Uri GetPreSignedUri(File file, TimeSpan expires)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Uri GetPreSignedUri(File<int> file, TimeSpan expires)
         {
             return GlobalStore.GetStore().GetPreSignedUri(string.Empty, GetUniqFilePath(file), expires,
                                                      new List<string>
@@ -340,16 +387,31 @@ namespace ASC.Files.Core.Data
         }
 
         public bool IsSupportedPreSignedUri(File file)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool IsSupportedPreSignedUri(File<int> file)
         {
             return GlobalStore.GetStore().IsSupportedPreSignedUri;
         }
 
         public Stream GetFileStream(File file)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Stream GetFileStream(File<int> file)
         {
             return GetFileStream(file, 0);
         }
 
         public File SaveFile(File file, Stream fileStream)
+        {
+            throw new NotImplementedException();
+        }
+
+        public File<int> SaveFile(File<int> file, Stream fileStream)
         {
             if (file == null)
             {
@@ -365,7 +427,7 @@ namespace ASC.Files.Core.Data
             if (CoreBaseSettings.Personal && SetupInfo.IsVisibleSettings("PersonalMaxSpace"))
             {
                 var personalMaxSpace = CoreConfiguration.PersonalMaxSpace(SettingsManager);
-                if (personalMaxSpace - GlobalSpace.GetUserUsedSpace(file.ID == null ? AuthContext.CurrentAccount.ID : file.CreateBy) < file.ContentLength)
+                if (personalMaxSpace - GlobalSpace.GetUserUsedSpace(file.ID == default ? AuthContext.CurrentAccount.ID : file.CreateBy) < file.ContentLength)
                 {
                     throw FileSizeComment.GetPersonalFreeSpaceException(personalMaxSpace);
                 }
@@ -377,7 +439,7 @@ namespace ASC.Files.Core.Data
             {
                 using var tx = FilesDbContext.Database.BeginTransaction();
 
-                if (file.ID == null)
+                if (file.ID == default)
                 {
                     file.ID = FilesDbContext.Files.Max(r => r.Id) + 1;
                     file.Version = 1;
@@ -395,7 +457,7 @@ namespace ASC.Files.Core.Data
                 if (file.CreateOn == default) file.CreateOn = TenantUtil.DateTimeNow();
 
                 var toUpdate = FilesDbContext.Files
-                    .Where(r => r.Id.ToString() == file.ID.ToString() && r.CurrentVersion && r.TenantId == TenantID)
+                    .Where(r => r.Id == file.ID && r.CurrentVersion && r.TenantId == TenantID)
                     .FirstOrDefault();
 
                 if (toUpdate != null)
@@ -406,7 +468,7 @@ namespace ASC.Files.Core.Data
 
                 var toInsert = new DbFile
                 {
-                    Id = (int)file.ID,
+                    Id = file.ID,
                     Version = file.Version,
                     VersionGroup = file.VersionGroup,
                     CurrentVersion = true,
@@ -486,9 +548,14 @@ namespace ASC.Files.Core.Data
         }
 
         public File ReplaceFileVersion(File file, Stream fileStream)
+        {
+            throw new NotImplementedException();
+        }
+
+        public File<int> ReplaceFileVersion(File<int> 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");
+            if (file.ID == default) throw new ArgumentException("No file id or folder id toFolderId determine provider");
 
             var maxChunkedUploadSize = SetupInfo.MaxChunkedUploadSize(TenantExtra, TenantStatisticProvider);
 
@@ -500,7 +567,7 @@ namespace ASC.Files.Core.Data
             if (CoreBaseSettings.Personal && SetupInfo.IsVisibleSettings("PersonalMaxSpace"))
             {
                 var personalMaxSpace = CoreConfiguration.PersonalMaxSpace(SettingsManager);
-                if (personalMaxSpace - GlobalSpace.GetUserUsedSpace(file.ID == null ? AuthContext.CurrentAccount.ID : file.CreateBy) < file.ContentLength)
+                if (personalMaxSpace - GlobalSpace.GetUserUsedSpace(file.ID == default ? AuthContext.CurrentAccount.ID : file.CreateBy) < file.ContentLength)
                 {
                     throw FileSizeComment.GetPersonalFreeSpaceException(personalMaxSpace);
                 }
@@ -521,7 +588,7 @@ namespace ASC.Files.Core.Data
                 if (file.CreateOn == default) file.CreateOn = TenantUtil.DateTimeNow();
 
                 var toUpdate = FilesDbContext.Files
-                    .Where(r => r.Id.ToString() == file.ID.ToString() && r.Version == file.Version)
+                    .Where(r => r.Id == file.ID && r.Version == file.Version)
                     .FirstOrDefault();
 
                 toUpdate.Version = file.Version;
@@ -588,14 +655,14 @@ namespace ASC.Files.Core.Data
             return GetFile(file.ID);
         }
 
-        private void DeleteVersion(File file)
+        private void DeleteVersion(File<int> file)
         {
             if (file == null
-                || file.ID == null
+                || file.ID == default
                 || file.Version <= 1) return;
 
             var toDelete = Query(FilesDbContext.Files)
-                .Where(r => r.Id == (int)file.ID)
+                .Where(r => r.Id == file.ID)
                 .Where(r => r.Version == file.Version)
                 .FirstOrDefault();
 
@@ -606,7 +673,7 @@ namespace ASC.Files.Core.Data
             FilesDbContext.SaveChanges();
 
             var toUpdate = Query(FilesDbContext.Files)
-                .Where(r => r.Id == (int)file.ID)
+                .Where(r => r.Id == file.ID)
                 .Where(r => r.Version == file.Version - 1)
                 .FirstOrDefault();
 
@@ -614,29 +681,34 @@ namespace ASC.Files.Core.Data
             FilesDbContext.SaveChanges();
         }
 
-        private void DeleteVersionStream(File file)
+        private void DeleteVersionStream(File<int> file)
         {
             GlobalStore.GetStore().DeleteDirectory(GetUniqFileVersionPath(file.ID, file.Version));
         }
 
-        private void SaveFileStream(File file, Stream stream)
+        private void SaveFileStream(File<int> file, Stream stream)
         {
             GlobalStore.GetStore().Save(string.Empty, GetUniqFilePath(file), stream, file.Title);
         }
 
         public void DeleteFile(object fileId)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void DeleteFile(int fileId)
         {
             DeleteFile(fileId, true);
         }
 
-        private void DeleteFile(object fileId, bool deleteFolder)
+        private void DeleteFile(int fileId, bool deleteFolder)
         {
-            if (fileId == null) return;
+            if (fileId == default) return;
             using var tx = FilesDbContext.Database.BeginTransaction();
 
-            var fromFolders = Query(FilesDbContext.Files).Where(r => r.Id == (int)fileId).GroupBy(r => r.Id).SelectMany(r => r.Select(a => a.FolderId)).Distinct().ToList();
+            var fromFolders = Query(FilesDbContext.Files).Where(r => r.Id == fileId).GroupBy(r => r.Id).SelectMany(r => r.Select(a => a.FolderId)).Distinct().ToList();
 
-            var toDeleteFiles = Query(FilesDbContext.Files).Where(r => r.Id == (int)fileId);
+            var toDeleteFiles = Query(FilesDbContext.Files).Where(r => r.Id == fileId);
             FilesDbContext.RemoveRange(toDeleteFiles);
 
             var toDeleteLinks = Query(FilesDbContext.TagLink).Where(r => r.EntryId == fileId.ToString()).Where(r => r.EntryType == FileEntryType.File);
@@ -667,33 +739,43 @@ namespace ASC.Files.Core.Data
         }
 
         public bool IsExist(string title, object folderId)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool IsExist(string title, int folderId)
         {
             return Query(FilesDbContext.Files)
                 .Where(r => r.Title == title)
-                .Where(r => r.FolderId == (int)folderId)
+                .Where(r => r.FolderId == folderId)
                 .Where(r => r.CurrentVersion)
                 .Any();
         }
 
         public object MoveFile(object fileId, object toFolderId)
         {
-            if (fileId == null) return null;
+            throw new NotImplementedException();
+        }
+
+        public int MoveFile(int fileId, int toFolderId)
+        {
+            if (fileId == default) return default;
 
             using (var tx = FilesDbContext.Database.BeginTransaction())
             {
                 var fromFolders = Query(FilesDbContext.Files)
-                    .Where(r => r.Id == (int)fileId)
+                    .Where(r => r.Id == fileId)
                     .GroupBy(r => r.Id)
                     .SelectMany(r => r.Select(a => a.FolderId))
                     .Distinct()
                     .ToList();
 
                 var toUpdate = Query(FilesDbContext.Files)
-                    .Where(r => r.Id == (int)fileId);
+                    .Where(r => r.Id == fileId);
 
                 foreach (var f in toUpdate)
                 {
-                    f.FolderId = (int)toFolderId;
+                    f.FolderId = toFolderId;
 
                     if (GlobalFolder.GetFolderTrash(FolderDao).Equals(toFolderId))
                     {
@@ -717,7 +799,7 @@ namespace ASC.Files.Core.Data
                 .ToList();
 
             var wrapper = ServiceProvider.GetService<FilesWrapper>();
-            wrapper.Id = (int)fileId;
+            wrapper.Id = fileId;
             wrapper.Folders = parentFoldersIds.Select(r => new FilesFoldersWrapper() { FolderId = r.ToString() }).ToList();
 
             FactoryIndexer.Update(wrapper,
@@ -728,11 +810,16 @@ namespace ASC.Files.Core.Data
         }
 
         public File CopyFile(object fileId, object toFolderId)
+        {
+            throw new NotImplementedException();
+        }
+
+        public File<int> CopyFile(int fileId, int toFolderId)
         {
             var file = GetFile(fileId);
             if (file != null)
             {
-                var copy = ServiceProvider.GetService<File>();
+                var copy = ServiceProvider.GetService<File<int>>();
                 copy.FileStatus = file.FileStatus;
                 copy.FolderID = toFolderId;
                 copy.Title = file.Title;
@@ -752,10 +839,15 @@ namespace ASC.Files.Core.Data
         }
 
         public object FileRename(File file, string newTitle)
+        {
+            throw new NotImplementedException();
+        }
+
+        public int FileRename(File<int> file, string newTitle)
         {
             newTitle = Global.ReplaceInvalidCharsAndTruncate(newTitle);
             var toUpdate = Query(FilesDbContext.Files)
-                .Where(r => r.Id == (int)file.ID)
+                .Where(r => r.Id == file.ID)
                 .Where(r => r.CurrentVersion)
                 .FirstOrDefault();
 
@@ -769,12 +861,17 @@ namespace ASC.Files.Core.Data
         }
 
         public string UpdateComment(object fileId, int fileVersion, string comment)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string UpdateComment(int fileId, int fileVersion, string comment)
         {
             comment ??= string.Empty;
             comment = comment.Substring(0, Math.Min(comment.Length, 255));
 
             var toUpdate = Query(FilesDbContext.Files)
-                .Where(r => r.Id == (int)fileId)
+                .Where(r => r.Id == fileId)
                 .Where(r => r.Version == fileVersion)
                 .FirstOrDefault();
 
@@ -786,9 +883,14 @@ namespace ASC.Files.Core.Data
         }
 
         public void CompleteVersion(object fileId, int fileVersion)
+        {
+
+        }
+
+        public void CompleteVersion(int fileId, int fileVersion)
         {
             var toUpdate = Query(FilesDbContext.Files)
-                .Where(r => r.Id == (int)fileId)
+                .Where(r => r.Id == fileId)
                 .Where(r => r.Version >= fileVersion);
 
             foreach (var f in toUpdate)
@@ -800,17 +902,22 @@ namespace ASC.Files.Core.Data
         }
 
         public void ContinueVersion(object fileId, int fileVersion)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void ContinueVersion(int fileId, int fileVersion)
         {
             using var tx = FilesDbContext.Database.BeginTransaction();
 
             var versionGroup = Query(FilesDbContext.Files)
-                .Where(r => r.Id == (int)fileId)
+                .Where(r => r.Id == fileId)
                 .Where(r => r.Version == fileVersion)
                 .Select(r => r.VersionGroup)
                 .FirstOrDefault();
 
             var toUpdate = Query(FilesDbContext.Files)
-                .Where(r => r.Id == (int)fileId)
+                .Where(r => r.Id == fileId)
                 .Where(r => r.Version >= fileVersion)
                 .Where(r => r.VersionGroup >= versionGroup);
 
@@ -825,35 +932,39 @@ namespace ASC.Files.Core.Data
         }
 
         public bool UseTrashForRemove(File file)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool UseTrashForRemove(File<int> file)
         {
             return file.RootFolderType != FolderType.TRASH;
         }
 
-        public static string GetUniqFileDirectory(object fileIdObject)
+        public string GetUniqFileDirectory(int fileId)
         {
-            if (fileIdObject == null) throw new ArgumentNullException("fileIdObject");
-            var fileIdInt = Convert.ToInt32(Convert.ToString(fileIdObject));
-            return string.Format("folder_{0}/file_{1}", (fileIdInt / 1000 + 1) * 1000, fileIdInt);
+            if (fileId == 0) throw new ArgumentNullException("fileIdObject");
+            return string.Format("folder_{0}/file_{1}", (Convert.ToInt32(fileId) / 1000 + 1) * 1000, fileId);
         }
 
-        public static string GetUniqFilePath(File file)
+        public string GetUniqFilePath(File<int> file)
         {
             return file != null
                        ? GetUniqFilePath(file, "content" + FileUtility.GetFileExtension(file.PureTitle))
                        : null;
         }
 
-        public static string GetUniqFilePath(File file, string fileTitle)
+        public string GetUniqFilePath(File<int> file, string fileTitle)
         {
             return file != null
                        ? string.Format("{0}/{1}", GetUniqFileVersionPath(file.ID, file.Version), fileTitle)
                        : null;
         }
 
-        public static string GetUniqFileVersionPath(object fileIdObject, int version)
+        public string GetUniqFileVersionPath(int fileId, int version)
         {
-            return fileIdObject != null
-                       ? string.Format("{0}/v{1}", GetUniqFileDirectory(fileIdObject), version)
+            return fileId != null
+                       ? string.Format("{0}/v{1}", GetUniqFileDirectory(fileId), version)
                        : null;
         }
 
@@ -864,12 +975,22 @@ namespace ASC.Files.Core.Data
 
         #region chunking
 
-        public ChunkedUploadSession CreateUploadSession(File file, long contentLength)
+        public ChunkedUploadSession<object> CreateUploadSession(File file, long contentLength)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ChunkedUploadSession<int> CreateUploadSession(File<int> file, long contentLength)
         {
             return ChunkedUploadSessionHolder.CreateUploadSession(file, contentLength);
         }
 
-        public void UploadChunk(ChunkedUploadSession uploadSession, Stream stream, long chunkLength)
+        public void UploadChunk(ChunkedUploadSession<object> uploadSession, Stream stream, long chunkLength)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void UploadChunk(ChunkedUploadSession<int> uploadSession, Stream stream, long chunkLength)
         {
             if (!uploadSession.UseChunks)
             {
@@ -892,7 +1013,7 @@ namespace ASC.Files.Core.Data
             }
         }
 
-        private File FinalizeUploadSession(ChunkedUploadSession uploadSession)
+        private File<int> FinalizeUploadSession(ChunkedUploadSession<int> uploadSession)
         {
             ChunkedUploadSessionHolder.FinalizeUploadSession(uploadSession);
 
@@ -903,14 +1024,19 @@ namespace ASC.Files.Core.Data
             return file;
         }
 
-        public void AbortUploadSession(ChunkedUploadSession uploadSession)
+        public void AbortUploadSession(ChunkedUploadSession<object> uploadSession)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void AbortUploadSession(ChunkedUploadSession<int> uploadSession)
         {
             ChunkedUploadSessionHolder.AbortUploadSession(uploadSession);
         }
 
-        private File GetFileForCommit(ChunkedUploadSession uploadSession)
+        private File<int> GetFileForCommit(ChunkedUploadSession<int> uploadSession)
         {
-            if (uploadSession.File.ID != null)
+            if (uploadSession.File.ID != default)
             {
                 var file = GetFile(uploadSession.File.ID);
                 file.Version++;
@@ -920,7 +1046,7 @@ namespace ASC.Files.Core.Data
                 file.Encrypted = uploadSession.Encrypted;
                 return file;
             }
-            var result = ServiceProvider.GetService<File>();
+            var result = ServiceProvider.GetService<File<int>>();
             result.FolderID = uploadSession.File.FolderID;
             result.Title = uploadSession.File.Title;
             result.ContentLength = uploadSession.BytesTotal;
@@ -935,10 +1061,15 @@ namespace ASC.Files.Core.Data
         #region Only in TMFileDao
 
         public void ReassignFiles(object[] fileIds, Guid newOwnerId)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void ReassignFiles(int[] fileIds, Guid newOwnerId)
         {
             var toUpdate = Query(FilesDbContext.Files)
                 .Where(r => r.CurrentVersion)
-                .Where(r => fileIds.Any(a => a.ToString() == r.Id.ToString()));
+                .Where(r => fileIds.Any(a => a == r.Id));
 
             foreach (var f in toUpdate)
             {
@@ -950,11 +1081,16 @@ namespace ASC.Files.Core.Data
 
         public List<File> GetFiles(object[] parentIds, FilterType filterType, bool subjectGroup, Guid subjectID, string searchText, bool searchInContent)
         {
-            if (parentIds == null || parentIds.Length == 0 || filterType == FilterType.FoldersOnly) return new List<File>();
+            throw new NotImplementedException();
+        }
+
+        public List<File<int>> GetFiles(int[] parentIds, FilterType filterType, bool subjectGroup, Guid subjectID, string searchText, bool searchInContent)
+        {
+            if (parentIds == null || parentIds.Length == 0 || filterType == FilterType.FoldersOnly) return new List<File<int>>();
 
             var q = GetFileQuery(r => r.CurrentVersion)
                 .Join(FilesDbContext.Tree, a => a.FolderId, t => t.FolderId, (file, tree) => new { file, tree })
-                .Where(r => parentIds.Any(a => a.ToString() == r.tree.ParentId.ToString()))
+                .Where(r => parentIds.Any(a => a == r.tree.ParentId))
                 .Select(r => r.file);
 
             if (!string.IsNullOrEmpty(searchText))
@@ -1006,6 +1142,11 @@ namespace ASC.Files.Core.Data
         }
 
         public IEnumerable<File> Search(string searchText, bool bunch)
+        {
+            throw new NotImplementedException();
+        }
+
+        IEnumerable<File<int>> IFileDao<int>.Search(string searchText, bool bunch)
         {
             if (FactoryIndexer.TrySelectIds(s => s.MatchAll(searchText), out var ids))
             {
@@ -1030,12 +1171,17 @@ namespace ASC.Files.Core.Data
             }
         }
 
-        private void DeleteFolder(object fileId)
+        private void DeleteFolder(int fileId)
         {
             GlobalStore.GetStore().DeleteDirectory(GetUniqFileDirectory(fileId));
         }
 
         public bool IsExistOnStorage(File file)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool IsExistOnStorage(File<int> file)
         {
             return GlobalStore.GetStore().IsFile(GetUniqFilePath(file));
         }
@@ -1043,6 +1189,11 @@ namespace ASC.Files.Core.Data
         private const string DiffTitle = "diff.zip";
 
         public void SaveEditHistory(File file, string changes, Stream differenceStream)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SaveEditHistory(File<int> file, string changes, Stream differenceStream)
         {
             if (file == null) throw new ArgumentNullException("file");
             if (string.IsNullOrEmpty(changes)) throw new ArgumentNullException("changes");
@@ -1051,7 +1202,7 @@ namespace ASC.Files.Core.Data
             changes = changes.Trim();
 
             var toUpdate = Query(FilesDbContext.Files)
-                .Where(r => r.Id == (int)file.ID)
+                .Where(r => r.Id == file.ID)
                 .Where(r => r.Version == file.Version);
 
             foreach (var f in toUpdate)
@@ -1065,9 +1216,14 @@ namespace ASC.Files.Core.Data
         }
 
         public List<EditHistory> GetEditHistory(DocumentServiceHelper documentServiceHelper, object fileId, int fileVersion = 0)
+        {
+            throw new NotImplementedException();
+        }
+
+        public List<EditHistory> GetEditHistory(DocumentServiceHelper documentServiceHelper, int fileId, int fileVersion = 0)
         {
             var query = Query(FilesDbContext.Files)
-                .Where(r => r.Id == (int)fileId)
+                .Where(r => r.Id == fileId)
                 .Where(r => r.Forcesave == ForcesaveType.None);
 
             if (fileVersion > 0)
@@ -1099,14 +1255,24 @@ namespace ASC.Files.Core.Data
         }
 
         public Stream GetDifferenceStream(File file)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Stream GetDifferenceStream(File<int> file)
         {
             return GlobalStore.GetStore().GetReadStream(string.Empty, GetUniqFilePath(file, DiffTitle));
         }
 
         public bool ContainChanges(object fileId, int fileVersion)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool ContainChanges(int fileId, int fileVersion)
         {
             return Query(FilesDbContext.Files)
-                .Where(r => r.Id == (int)fileId)
+                .Where(r => r.Id == fileId)
                 .Where(r => r.Version == fileVersion)
                 .Where(r => r.Changes != null)
                 .Any();
@@ -1160,7 +1326,7 @@ namespace ASC.Files.Core.Data
                {
                    if (subjectGroup)
                    {
-                       var users = UserManager.GetUsersByGroup(subjectID).Select(u => u.ID.ToString()).ToArray();
+                       var users = UserManager.GetUsersByGroup(subjectID).Select(u => u.ID).ToArray();
                        result.In(r => r.CreateBy, users);
                    }
                    else
@@ -1185,7 +1351,7 @@ namespace ASC.Files.Core.Data
            };
         }
 
-        protected List<File> FromQueryWithShared(IQueryable<DbFile> dbFiles)
+        protected List<File<int>> FromQueryWithShared(IQueryable<DbFile> dbFiles)
         {
             return dbFiles
                 .Select(r => new DbFileQuery
@@ -1210,32 +1376,7 @@ namespace ASC.Files.Core.Data
                 .ToList();
         }
 
-        protected List<File<int>> FromQueryWithSharedInt(IQueryable<DbFile> dbFiles)
-        {
-            return dbFiles
-                .Select(r => new DbFileQuery
-                {
-                    file = r,
-                    root =
-                    FilesDbContext.Folders
-                        .Join(FilesDbContext.Tree, a => a.Id, b => b.ParentId, (folder, tree) => new { folder, tree })
-                        .Where(x => x.folder.TenantId == r.TenantId)
-                        .Where(x => x.tree.FolderId == r.FolderId)
-                        .OrderByDescending(r => r.tree.Level)
-                        .Select(r => r.folder)
-                        .FirstOrDefault(),
-                    shared =
-                     FilesDbContext.Security
-                        .Where(x => x.EntryType == FileEntryType.File)
-                        .Where(x => x.EntryId == r.Id.ToString())
-                        .Any()
-                })
-                .ToList()
-                .Select(ToFileInt)
-                .ToList();
-        }
-
-        protected List<File> FromQuery(IQueryable<DbFile> dbFiles)
+        protected List<File<int>> FromQuery(IQueryable<DbFile> dbFiles)
         {
             return dbFiles
                 .Select(r => new DbFileQuery
@@ -1255,31 +1396,7 @@ namespace ASC.Files.Core.Data
                 .ToList();
         }
 
-        public File ToFile(DbFileQuery r)
-        {
-            var file = ServiceProvider.GetService<File>();
-            file.ID = r.file.Id;
-            file.Title = r.file.Title;
-            file.FolderID = r.file.FolderId;
-            file.CreateOn = TenantUtil.DateTimeFromUtc(r.file.CreateOn);
-            file.CreateBy = r.file.CreateBy;
-            file.Version = r.file.Version;
-            file.VersionGroup = r.file.VersionGroup;
-            file.ContentLength = r.file.ContentLength;
-            file.ModifiedOn = TenantUtil.DateTimeFromUtc(r.file.ModifiedOn);
-            file.ModifiedBy = r.file.ModifiedBy;
-            file.RootFolderType = r.root?.FolderType ?? default;
-            file.RootFolderCreator = r.root?.CreateBy ?? default;
-            file.RootFolderId = r.root?.Id ?? default;
-            file.Shared = r.shared;
-            file.ConvertedType = r.file.ConvertedType;
-            file.Comment = r.file.Comment;
-            file.Encrypted = r.file.Encrypted;
-            file.Forcesave = r.file.Forcesave;
-            return file;
-        }
-
-        public File<int> ToFileInt(DbFileQuery r)
+        public File<int> ToFile(DbFileQuery r)
         {
             var file = ServiceProvider.GetService<File<int>>();
             file.ID = r.file.Id;
@@ -1302,169 +1419,6 @@ namespace ASC.Files.Core.Data
             file.Forcesave = r.file.Forcesave;
             return file;
         }
-
-
-        ///test:test
-
-        public File<int> GetFile(int fileId, int fileVersion)
-        {
-            throw new NotImplementedException();
-        }
-
-        public File<int> GetFile(int parentId, string title)
-        {
-            throw new NotImplementedException();
-        }
-
-        public File<int> GetFileStable(int fileId, int fileVersion = -1)
-        {
-            throw new NotImplementedException();
-        }
-
-        public List<File<int>> GetFileHistory(int fileId)
-        {
-            throw new NotImplementedException();
-        }
-
-        public List<File<int>> GetFiles(int[] fileIds)
-        {
-            throw new NotImplementedException();
-        }
-
-        public List<File<int>> GetFilesForShare(int[] fileIds, FilterType filterType, bool subjectGroup, Guid subjectID, string searchText, bool searchInContent)
-        {
-            throw new NotImplementedException();
-        }
-
-        public List<object> GetFiles(int parentId)
-        {
-            throw new NotImplementedException();
-        }
-
-        public List<File<int>> GetFiles(int parentId, OrderBy orderBy, FilterType filterType, bool subjectGroup, Guid subjectID, string searchText, bool searchInContent, bool withSubfolders = false)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Stream GetFileStream(File<int> file)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Stream GetFileStream(File<int> file, long offset)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Uri GetPreSignedUri(File<int> file, TimeSpan expires)
-        {
-            throw new NotImplementedException();
-        }
-
-        public bool IsSupportedPreSignedUri(File<int> file)
-        {
-            throw new NotImplementedException();
-        }
-
-        public File<int> SaveFile(File<int> file, Stream fileStream)
-        {
-            throw new NotImplementedException();
-        }
-
-        public File<int> ReplaceFileVersion(File<int> file, Stream fileStream)
-        {
-            throw new NotImplementedException();
-        }
-
-        public void DeleteFile(int fileId)
-        {
-            throw new NotImplementedException();
-        }
-
-        public bool IsExist(string title, int folderId)
-        {
-            throw new NotImplementedException();
-        }
-
-        public object MoveFile(int fileId, int toFolderId)
-        {
-            throw new NotImplementedException();
-        }
-
-        public File<int> CopyFile(int fileId, int toFolderId)
-        {
-            throw new NotImplementedException();
-        }
-
-        public object FileRename(File<int> file, string newTitle)
-        {
-            throw new NotImplementedException();
-        }
-
-        public string UpdateComment(int fileId, int fileVersion, string comment)
-        {
-            throw new NotImplementedException();
-        }
-
-        public void CompleteVersion(int fileId, int fileVersion)
-        {
-            throw new NotImplementedException();
-        }
-
-        public void ContinueVersion(int fileId, int fileVersion)
-        {
-            throw new NotImplementedException();
-        }
-
-        public bool UseTrashForRemove(File<int> file)
-        {
-            throw new NotImplementedException();
-        }
-
-        public ChunkedUploadSession CreateUploadSession(File<int> file, long contentLength)
-        {
-            throw new NotImplementedException();
-        }
-
-        public void ReassignFiles(int[] fileIds, Guid newOwnerId)
-        {
-            throw new NotImplementedException();
-        }
-
-        public List<File<int>> GetFiles(int[] parentIds, FilterType filterType, bool subjectGroup, Guid subjectID, string searchText, bool searchInContent)
-        {
-            throw new NotImplementedException();
-        }
-
-        IEnumerable<File<int>> IFileDao<int>.Search(string text, bool bunch)
-        {
-            throw new NotImplementedException();
-        }
-
-        public bool IsExistOnStorage(File<int> file)
-        {
-            throw new NotImplementedException();
-        }
-
-        public void SaveEditHistory(File<int> file, string changes, Stream differenceStream)
-        {
-            throw new NotImplementedException();
-        }
-
-        public List<EditHistory> GetEditHistory(DocumentServiceHelper documentServiceHelper, int fileId, int fileVersion = 0)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Stream GetDifferenceStream(File<int> file)
-        {
-            throw new NotImplementedException();
-        }
-
-        public bool ContainChanges(int fileId, int fileVersion)
-        {
-            throw new NotImplementedException();
-        }
     }
 
     public class DbFileQuery

products/ASC.Files/Server/Core/Dao/TeamlabDao/FolderDao.cs

@@ -50,7 +50,7 @@ using Microsoft.Extensions.Options;
 
 namespace ASC.Files.Core.Data
 {
-    public class FolderDao : AbstractDao, IFolderDao
+    public class FolderDao : AbstractDao, IFolderDao, IFolderDao<int>
     {
         private const string my = "my";
         private const string common = "common";
@@ -99,24 +99,38 @@ namespace ASC.Files.Core.Data
 
         public Folder GetFolder(object folderId)
         {
-            var query = GetFolderQuery(r => r.Id.ToString() == folderId.ToString());
+            throw new NotImplementedException();
+        }
+
+        public Folder<int> GetFolder(int folderId)
+        {
+            var query = GetFolderQuery(r => r.Id == folderId);
             return FromQueryWithShared(query).SingleOrDefault();
         }
 
         public Folder GetFolder(string title, object parentId)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Folder<int> GetFolder(string title, int parentId)
         {
             if (string.IsNullOrEmpty(title)) throw new ArgumentNullException(title);
 
-            var query = GetFolderQuery(r => r.Title == title && r.ParentId.ToString() == parentId.ToString())
+            var query = GetFolderQuery(r => r.Title == title && r.ParentId == parentId)
                 .OrderBy(r => r.CreateOn);
 
             return FromQueryWithShared(query).FirstOrDefault();
         }
 
         public Folder GetRootFolder(object folderId)
+        {
+            throw new NotImplementedException();
+        }
+        public Folder<int> GetRootFolder(int folderId)
         {
             var id = FilesDbContext.Tree
-                .Where(r => r.FolderId == (int)folderId)
+                .Where(r => r.FolderId == folderId)
                 .OrderByDescending(r => r.Level)
                 .Select(r => r.ParentId)
                 .FirstOrDefault();
@@ -127,9 +141,13 @@ namespace ASC.Files.Core.Data
         }
 
         public Folder GetRootFolderByFile(object fileId)
+        {
+            throw new NotImplementedException();
+        }
+        public Folder<int> GetRootFolderByFile(int fileId)
         {
             var subq = Query(FilesDbContext.Files)
-                .Where(r => r.Id == (int)fileId && r.CurrentVersion)
+                .Where(r => r.Id == fileId && r.CurrentVersion)
                 .Select(r => r.FolderId)
                 .Distinct();
 
@@ -144,17 +162,26 @@ namespace ASC.Files.Core.Data
         }
 
         public List<Folder> GetFolders(object parentId)
+        {
+            throw new NotImplementedException();
+        }
+        public List<Folder<int>> GetFolders(int parentId)
         {
             return GetFolders(parentId, default, default, false, default, string.Empty);
         }
 
         public List<Folder> GetFolders(object parentId, OrderBy orderBy, FilterType filterType, bool subjectGroup, Guid subjectID, string searchText, bool withSubfolders = false)
+        {
+            throw new NotImplementedException();
+        }
+
+        public List<Folder<int>> GetFolders(int parentId, OrderBy orderBy, FilterType filterType, bool subjectGroup, Guid subjectID, string searchText, bool withSubfolders = false)
         {
             if (filterType == FilterType.FilesOnly || filterType == FilterType.ByExtension
                 || filterType == FilterType.DocumentsOnly || filterType == FilterType.ImagesOnly
                 || filterType == FilterType.PresentationsOnly || filterType == FilterType.SpreadsheetsOnly
                 || filterType == FilterType.ArchiveOnly || filterType == FilterType.MediaOnly)
-                return new List<Folder>();
+                return new List<Folder<int>>();
 
             if (orderBy == null) orderBy = new OrderBy(SortedByType.DateAndTime, false);
 
@@ -164,7 +191,7 @@ namespace ASC.Files.Core.Data
             {
                 q = GetFolderQuery()
                     .Join(FilesDbContext.Tree, r => r.Id, a => a.FolderId, (folder, tree) => new { folder, tree })
-                    .Where(r => r.tree.ParentId.ToString() == parentId.ToString() && r.tree.Level != 0)
+                    .Where(r => r.tree.ParentId == parentId && r.tree.Level != 0)
                     .Select(r => r.folder);
             }
 
@@ -216,21 +243,25 @@ namespace ASC.Files.Core.Data
         }
 
         public List<Folder> GetFolders(object[] folderIds, FilterType filterType = FilterType.None, bool subjectGroup = false, Guid? subjectID = null, string searchText = "", bool searchSubfolders = false, bool checkShare = true)
+        {
+            throw new NotImplementedException();
+        }
+
+        public List<Folder<int>> GetFolders(int[] folderIds, FilterType filterType = FilterType.None, bool subjectGroup = false, Guid? subjectID = null, string searchText = "", bool searchSubfolders = false, bool checkShare = true)
         {
             if (filterType == FilterType.FilesOnly || filterType == FilterType.ByExtension
                 || filterType == FilterType.DocumentsOnly || filterType == FilterType.ImagesOnly
                 || filterType == FilterType.PresentationsOnly || filterType == FilterType.SpreadsheetsOnly
                 || filterType == FilterType.ArchiveOnly || filterType == FilterType.MediaOnly)
-                return new List<Folder>();
+                return new List<Folder<int>>();
 
-            var folderIdsStrings = folderIds.Select(r => r.ToString()).ToList();
-            var q = GetFolderQuery(r => folderIdsStrings.Any(q => q == r.Id.ToString()));
+            var q = GetFolderQuery(r => folderIds.Any(q => q == r.Id));
 
             if (searchSubfolders)
             {
                 q = GetFolderQuery()
                     .Join(FilesDbContext.Tree, r => r.Id, a => a.FolderId, (folder, tree) => new { folder, tree })
-                    .Where(r => folderIdsStrings.Any(q => q == r.folder.ParentId.ToString()))
+                    .Where(r => folderIds.Any(q => q == r.folder.ParentId))
                     .Select(r => r.folder);
             }
 
@@ -269,10 +300,14 @@ namespace ASC.Files.Core.Data
 
         public List<Folder> GetParentFolders(object folderId)
         {
-            var folderIdString = folderId.ToString();
+            throw new NotImplementedException();
+        }
+
+        public List<Folder<int>> GetParentFolders(int folderId)
+        {
             var q = GetFolderQuery()
                 .Join(FilesDbContext.Tree, r => r.Id, a => a.ParentId, (folder, tree) => new { folder, tree })
-                .Where(r => r.tree.FolderId.ToString() == folderIdString)
+                .Where(r => r.tree.FolderId == folderId)
                 .OrderByDescending(r => r.tree.Level)
                 .Select(r => r.folder);
 
@@ -280,6 +315,11 @@ namespace ASC.Files.Core.Data
         }
 
         public object SaveFolder(Folder folder)
+        {
+            throw new NotImplementedException();
+        }
+
+        public int SaveFolder(Folder<int> folder)
         {
             if (folder == null) throw new ArgumentNullException("folder");
 
@@ -295,10 +335,10 @@ namespace ASC.Files.Core.Data
 
             using (var tx = FilesDbContext.Database.BeginTransaction())
             {
-                if (folder.ID != null && IsExist(folder.ID))
+                if (folder.ID != default && IsExist(folder.ID))
                 {
                     var toUpdate = Query(FilesDbContext.Folders)
-                        .Where(r => r.Id == (int)folder.ID)
+                        .Where(r => r.Id == folder.ID)
                         .FirstOrDefault();
 
                     toUpdate.Title = folder.Title;
@@ -314,7 +354,7 @@ namespace ASC.Files.Core.Data
                     var newFolder = new DbFolder
                     {
                         Id = 0,
-                        ParentId = (int)folder.ParentFolderID,
+                        ParentId = folder.ParentFolderID,
                         Title = folder.Title,
                         CreateOn = TenantUtil.DateTimeToUtc(folder.CreateOn),
                         CreateBy = folder.CreateBy,
@@ -331,8 +371,8 @@ namespace ASC.Files.Core.Data
                     //itself link
                     var newTree = new DbFolderTree
                     {
-                        FolderId = (int)folder.ID,
-                        ParentId = (int)folder.ID,
+                        FolderId = folder.ID,
+                        ParentId = folder.ID,
                         Level = 0
                     };
 
@@ -341,12 +381,12 @@ namespace ASC.Files.Core.Data
 
                     //full path to root
                     var oldTree = FilesDbContext.Tree
-                        .Where(r => r.FolderId == (int)folder.ParentFolderID)
+                        .Where(r => r.FolderId == folder.ParentFolderID)
                         .FirstOrDefault();
 
                     var treeToAdd = new DbFolderTree
                     {
-                        FolderId = (int)folder.ID,
+                        FolderId = folder.ID,
                         ParentId = oldTree.ParentId,
                         Level = oldTree.Level + 1
                     };
@@ -367,20 +407,20 @@ namespace ASC.Files.Core.Data
             return folder.ID;
         }
 
-        private bool IsExist(object folderId)
+        private bool IsExist(int folderId)
         {
             return Query(FilesDbContext.Folders)
-                .Where(r => r.Id == (int)folderId)
+                .Where(r => r.Id == folderId)
                 .Any();
         }
 
         public void DeleteFolder(object folderId)
         {
-            if (folderId == null) throw new ArgumentNullException("folderId");
-
-            var id = int.Parse(Convert.ToString(folderId));
-
-            if (id == 0) return;
+            throw new NotImplementedException();
+        }
+        public void DeleteFolder(int id)
+        {
+            if (id == default) throw new ArgumentNullException("folderId");
 
             using (var tx = FilesDbContext.Database.BeginTransaction())
             {
@@ -431,10 +471,14 @@ namespace ASC.Files.Core.Data
                 RecalculateFoldersCount(parent);
             }
 
-            FactoryIndexer.DeleteAsync(new FoldersWrapper { Id = (int)folderId });
+            FactoryIndexer.DeleteAsync(new FoldersWrapper { Id = (int)id });
         }
 
         public object MoveFolder(object folderId, object toFolderId, CancellationToken? cancellationToken)
+        {
+            throw new NotImplementedException();
+        }
+        public int MoveFolder(int folderId, int toFolderId, CancellationToken? cancellationToken)
         {
             using (var tx = FilesDbContext.Database.BeginTransaction())
             {
@@ -443,26 +487,26 @@ namespace ASC.Files.Core.Data
                 if (folder.FolderType != FolderType.DEFAULT)
                     throw new ArgumentException("It is forbidden to move the System folder.", "folderId");
 
-                var recalcFolders = new List<object> { toFolderId };
+                var recalcFolders = new List<int> { toFolderId };
                 var parent = FilesDbContext.Folders
-                    .Where(r => r.Id == (int)folderId)
+                    .Where(r => r.Id == folderId)
                     .Select(r => r.ParentId)
                     .FirstOrDefault();
 
                 if (parent != 0 && !recalcFolders.Contains(parent)) recalcFolders.Add(parent);
 
                 var toUpdate = Query(FilesDbContext.Folders)
-                    .Where(r => r.Id == (int)folderId)
+                    .Where(r => r.Id == folderId)
                     .FirstOrDefault();
 
-                toUpdate.ParentId = (int)toFolderId;
+                toUpdate.ParentId = toFolderId;
                 toUpdate.ModifiedOn = DateTime.UtcNow;
                 toUpdate.ModifiedBy = AuthContext.CurrentAccount.ID;
 
                 FilesDbContext.SaveChanges();
 
                 var subfolders = FilesDbContext.Tree
-                    .Where(r => r.ParentId == (int)folderId)
+                    .Where(r => r.ParentId == folderId)
                     .ToDictionary(r => r.FolderId, r => r.Level);
 
                 var toDelete = FilesDbContext.Tree
@@ -472,7 +516,7 @@ namespace ASC.Files.Core.Data
                 FilesDbContext.SaveChanges();
 
                 var toInsert = FilesDbContext.Tree
-                    .Where(r => r.FolderId == (int)toFolderId)
+                    .Where(r => r.FolderId == toFolderId)
                     .ToList();
 
                 foreach (var subfolder in subfolders)
@@ -499,6 +543,10 @@ namespace ASC.Files.Core.Data
         }
 
         public Folder CopyFolder(object folderId, object toFolderId, CancellationToken? cancellationToken)
+        {
+            throw new NotImplementedException();
+        }
+        public Folder<int> CopyFolder(int folderId, int toFolderId, CancellationToken? cancellationToken)
         {
             var folder = GetFolder(folderId);
 
@@ -507,7 +555,7 @@ namespace ASC.Files.Core.Data
             if (folder.FolderType == FolderType.BUNCH)
                 folder.FolderType = FolderType.DEFAULT;
 
-            var copy = ServiceProvider.GetService<Folder>();
+            var copy = ServiceProvider.GetService<Folder<int>>();
             copy.ParentFolderID = toFolderId;
             copy.RootFolderId = toFolder.RootFolderId;
             copy.RootFolderCreator = toFolder.RootFolderCreator;
@@ -523,13 +571,17 @@ namespace ASC.Files.Core.Data
 
         public IDictionary<object, string> CanMoveOrCopy(object[] folderIds, object to)
         {
-            var result = new Dictionary<object, string>();
+            throw new NotImplementedException();
+        }
+        public IDictionary<int, string> CanMoveOrCopy(int[] folderIds, int to)
+        {
+            var result = new Dictionary<int, string>();
 
             foreach (var folderId in folderIds)
             {
                 var exists = FilesDbContext.Tree
-                    .Where(r => r.ParentId == (int)folderId)
-                    .Where(r => r.FolderId == (int)to)
+                    .Where(r => r.ParentId == folderId)
+                    .Where(r => r.FolderId == to)
                     .Any();
 
                 if (exists)
@@ -538,13 +590,13 @@ namespace ASC.Files.Core.Data
                 }
 
                 var title = Query(FilesDbContext.Folders)
-                    .Where(r => r.Id == (int)folderId)
+                    .Where(r => r.Id == folderId)
                     .Select(r => r.Title.ToLower())
                     .FirstOrDefault();
 
                 var conflict = Query(FilesDbContext.Folders)
                     .Where(r => r.Title.ToLower() == title)
-                    .Where(r => r.ParentId == (int)to)
+                    .Where(r => r.ParentId == to)
                     .Select(r => r.Id)
                     .FirstOrDefault();
 
@@ -552,15 +604,15 @@ namespace ASC.Files.Core.Data
                 {
                     FilesDbContext.Files
                         .Join(FilesDbContext.Files, f1 => f1.Title.ToLower(), f2 => f2.Title.ToLower(), (f1, f2) => new { f1, f2 })
-                        .Where(r => r.f1.TenantId == TenantID && r.f1.CurrentVersion && r.f1.FolderId == (int)folderId)
-                        .Where(r => r.f2.TenantId == TenantID && r.f2.CurrentVersion && r.f2.FolderId == (int)conflict)
+                        .Where(r => r.f1.TenantId == TenantID && r.f1.CurrentVersion && r.f1.FolderId == folderId)
+                        .Where(r => r.f2.TenantId == TenantID && r.f2.CurrentVersion && r.f2.FolderId == conflict)
                         .Select(r => r.f1)
                         .ToList()
                         .ForEach(r => result[r.Id] = r.Title);
 
                     var childs = Query(FilesDbContext.Folders)
-                        .Where(r => r.ParentId == (int)folderId)
-                        .Select(r => r.Id.ToString());
+                        .Where(r => r.ParentId == folderId)
+                        .Select(r => r.Id);
 
                     foreach (var pair in CanMoveOrCopy(childs.ToArray(), conflict))
                     {
@@ -573,9 +625,14 @@ namespace ASC.Files.Core.Data
         }
 
         public object RenameFolder(Folder folder, string newTitle)
+        {
+            throw new NotImplementedException();
+        }
+
+        public int RenameFolder(Folder<int> folder, string newTitle)
         {
             var toUpdate = Query(FilesDbContext.Folders)
-                .Where(r => r.Id == (int)folder.ID)
+                .Where(r => r.Id == folder.ID)
                 .FirstOrDefault();
 
             toUpdate.Title = Global.ReplaceInvalidCharsAndTruncate(newTitle);
@@ -588,52 +645,82 @@ namespace ASC.Files.Core.Data
         }
 
         public int GetItemsCount(object folderId)
+        {
+            throw new NotImplementedException();
+        }
+
+        public int GetItemsCount(int folderId)
         {
             return GetFoldersCount(folderId) +
                    GetFilesCount(folderId);
         }
 
-        private int GetFoldersCount(object parentId)
+        private int GetFoldersCount(int parentId)
         {
             var count = FilesDbContext.Tree
-                .Where(r => r.ParentId == (int)parentId)
+                .Where(r => r.ParentId == parentId)
                 .Where(r => r.Level >= 0)
                 .Count();
 
             return count;
         }
 
-        private int GetFilesCount(object folderId)
+        private int GetFilesCount(int folderId)
         {
             var count = Query(FilesDbContext.Files)
                 .Distinct()
-                .Where(r => FilesDbContext.Tree.Where(r => r.ParentId == (int)folderId).Select(r => r.FolderId).Any(b => b == r.FolderId))
+                .Where(r => FilesDbContext.Tree.Where(r => r.ParentId == folderId).Select(r => r.FolderId).Any(b => b == r.FolderId))
                 .Count();
 
             return count;
         }
 
         public bool IsEmpty(object folderId)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool IsEmpty(int folderId)
         {
             return GetItemsCount(folderId) == 0;
         }
 
         public bool UseTrashForRemove(Folder folder)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool UseTrashForRemove(Folder<int> folder)
         {
             return folder.RootFolderType != FolderType.TRASH && folder.FolderType != FolderType.BUNCH;
         }
 
         public bool UseRecursiveOperation(object folderId, object toRootFolderId)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool UseRecursiveOperation(int folderId, int toRootFolderId)
         {
             return true;
         }
 
         public bool CanCalculateSubitems(object entryId)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool CanCalculateSubitems(int entryId)
         {
             return true;
         }
 
         public long GetMaxUploadSize(object folderId, bool chunkedUpload)
+        {
+            throw new NotImplementedException();
+        }
+
+        public long GetMaxUploadSize(int folderId, bool chunkedUpload)
         {
             var tmp = long.MaxValue;
 
@@ -643,15 +730,15 @@ namespace ASC.Files.Core.Data
             return Math.Min(tmp, chunkedUpload ? SetupInfo.MaxChunkedUploadSize(TenantExtra, TenantStatisticProvider) : SetupInfo.MaxUploadSize(TenantExtra, TenantStatisticProvider));
         }
 
-        private void RecalculateFoldersCount(object id)
+        private void RecalculateFoldersCount(int id)
         {
             var toUpdate = Query(FilesDbContext.Folders)
-                .Where(r => FilesDbContext.Tree.Where(a => a.FolderId == (int)id).Select(a => a.ParentId).Any(a => a == r.Id))
+                .Where(r => FilesDbContext.Tree.Where(a => a.FolderId == id).Select(a => a.ParentId).Any(a => a == r.Id))
                 .ToList();
 
             foreach (var f in toUpdate)
             {
-                var count = FilesDbContext.Tree.Where(r => r.ParentId == (int)id).Count() - 1;
+                var count = FilesDbContext.Tree.Where(r => r.ParentId == id).Count() - 1;
                 f.FoldersCount = count;
             }
 
@@ -661,9 +748,14 @@ namespace ASC.Files.Core.Data
         #region Only for TMFolderDao
 
         public void ReassignFolders(object[] folderIds, Guid newOwnerId)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void ReassignFolders(int[] folderIds, Guid newOwnerId)
         {
             var toUpdate = Query(FilesDbContext.Folders)
-                .Where(r => folderIds.Any(a => r.Id == (int)a));
+                .Where(r => folderIds.Any(a => r.Id == a));
 
             foreach (var f in toUpdate)
             {
@@ -674,15 +766,20 @@ namespace ASC.Files.Core.Data
         }
 
         public IEnumerable<Folder> Search(string text, bool bunch)
+        {
+            throw new NotImplementedException();
+        }
+
+        IEnumerable<Folder<int>> IFolderDao<int>.Search(string text, bool bunch)
         {
             return Search(text).Where(f => bunch
                                                ? f.RootFolderType == FolderType.BUNCH
                                                : (f.RootFolderType == FolderType.USER || f.RootFolderType == FolderType.COMMON)).ToList();
         }
 
-        private IEnumerable<Folder> Search(string text)
+        private IEnumerable<Folder<int>> Search(string text)
         {
-            if (string.IsNullOrEmpty(text)) return new List<Folder>();
+            if (string.IsNullOrEmpty(text)) return new List<Folder<int>>();
 
             if (FactoryIndexer.TrySelectIds(s => s.MatchAll(text), out var ids))
             {
@@ -695,6 +792,11 @@ namespace ASC.Files.Core.Data
         }
 
         public virtual IEnumerable<object> GetFolderIDs(string module, string bunch, IEnumerable<string> data, bool createIfNotExists)
+        {
+            throw new NotImplementedException();
+        }
+
+        public virtual IEnumerable<int> GetFolderIDs(string module, string bunch, IEnumerable<int> data, bool createIfNotExists)
         {
             if (string.IsNullOrEmpty(module)) throw new ArgumentNullException("module");
             if (string.IsNullOrEmpty(bunch)) throw new ArgumentNullException("bunch");
@@ -705,14 +807,14 @@ namespace ASC.Files.Core.Data
                 .Where(r => keys.Length > 1 ? keys.Any(a => a == r.RightNode) : r.RightNode == keys[0])
                 .ToDictionary(r => r.RightNode, r => r.LeftNode);
 
-            var folderIds = new List<object>();
+            var folderIds = new List<int>();
 
             foreach (var key in keys)
             {
-                string folderId = null;
-                if (createIfNotExists && !folderIdsDictionary.TryGetValue(key, out folderId))
+                int newFolderId = 0;
+                if (createIfNotExists && !folderIdsDictionary.TryGetValue(key, out var folderId))
                 {
-                    var folder = ServiceProvider.GetService<Folder>();
+                    var folder = ServiceProvider.GetService<Folder<int>>();
                     switch (bunch)
                     {
                         case my:
@@ -742,11 +844,11 @@ namespace ASC.Files.Core.Data
                     }
                     using var tx = FilesDbContext.Database.BeginTransaction();//NOTE: Maybe we shouldn't start transaction here at all
 
-                    folderId = (string)SaveFolder(folder); //Save using our db manager
+                    newFolderId = SaveFolder(folder); //Save using our db manager
 
                     var newBunch = new DbFilesBunchObjects
                     {
-                        LeftNode = folderId,
+                        LeftNode = newFolderId.ToString(),
                         RightNode = key,
                         TenantId = TenantID
                     };
@@ -756,12 +858,17 @@ namespace ASC.Files.Core.Data
 
                     tx.Commit(); //Commit changes
                 }
-                folderIds.Add(folderId);
+                folderIds.Add(newFolderId);
             }
             return folderIds;
         }
 
         public virtual object GetFolderID(string module, string bunch, string data, bool createIfNotExists)
+        {
+            throw new NotImplementedException();
+        }
+
+        public virtual int GetFolderID(string module, string bunch, Guid data, bool createIfNotExists)
         {
             if (string.IsNullOrEmpty(module)) throw new ArgumentNullException("module");
             if (string.IsNullOrEmpty(bunch)) throw new ArgumentNullException("bunch");
@@ -772,16 +879,17 @@ namespace ASC.Files.Core.Data
                 .Select(r => r.LeftNode)
                 .FirstOrDefault();
 
+            int newFolderId = 0;
             if (createIfNotExists && folderId == null)
             {
-                var folder = ServiceProvider.GetService<Folder>();
+                var folder = ServiceProvider.GetService<Folder<int>>();
                 folder.ParentFolderID = 0;
                 switch (bunch)
                 {
                     case my:
                         folder.FolderType = FolderType.USER;
                         folder.Title = my;
-                        folder.CreateBy = new Guid(data);
+                        folder.CreateBy = data;
                         break;
                     case common:
                         folder.FolderType = FolderType.COMMON;
@@ -790,7 +898,7 @@ namespace ASC.Files.Core.Data
                     case trash:
                         folder.FolderType = FolderType.TRASH;
                         folder.Title = trash;
-                        folder.CreateBy = new Guid(data);
+                        folder.CreateBy = data;
                         break;
                     case share:
                         folder.FolderType = FolderType.SHARE;
@@ -806,10 +914,10 @@ namespace ASC.Files.Core.Data
                         break;
                 }
                 using var tx = FilesDbContext.Database.BeginTransaction(); //NOTE: Maybe we shouldn't start transaction here at all
-                folderId = (string)SaveFolder(folder); //Save using our db manager
+                newFolderId = SaveFolder(folder); //Save using our db manager
                 var toInsert = new DbFilesBunchObjects
                 {
-                    LeftNode = folderId,
+                    LeftNode = newFolderId.ToString(),
                     RightNode = key,
                     TenantId = TenantID
                 };
@@ -818,28 +926,48 @@ namespace ASC.Files.Core.Data
                 tx.Commit(); //Commit changes
             }
 
-            return Convert.ToInt32(folderId);
+            return newFolderId;
         }
 
 
         public object GetFolderIDProjects(bool createIfNotExists)
         {
-            return GetFolderID(FileConstant.ModuleId, projects, null, createIfNotExists);
+            throw new NotImplementedException();
+        }
+
+        int IFolderDao<int>.GetFolderIDProjects(bool createIfNotExists)
+        {
+            return GetFolderID(FileConstant.ModuleId, projects, Guid.Empty, createIfNotExists);
         }
 
         public object GetFolderIDTrash(bool createIfNotExists, Guid? userId = null)
         {
-            return GetFolderID(FileConstant.ModuleId, trash, (userId ?? AuthContext.CurrentAccount.ID).ToString(), createIfNotExists);
+            throw new NotImplementedException();
+        }
+
+        int IFolderDao<int>.GetFolderIDTrash(bool createIfNotExists, Guid? userId = null)
+        {
+            return GetFolderID(FileConstant.ModuleId, trash, (userId ?? AuthContext.CurrentAccount.ID), createIfNotExists);
         }
 
         public object GetFolderIDCommon(bool createIfNotExists)
         {
-            return GetFolderID(FileConstant.ModuleId, common, null, createIfNotExists);
+            throw new NotImplementedException();
+        }
+
+        int IFolderDao<int>.GetFolderIDCommon(bool createIfNotExists)
+        {
+            return GetFolderID(FileConstant.ModuleId, common, Guid.Empty, createIfNotExists);
         }
 
         public object GetFolderIDUser(bool createIfNotExists, Guid? userId = null)
         {
-            return GetFolderID(FileConstant.ModuleId, my, (userId ?? AuthContext.CurrentAccount.ID).ToString(), createIfNotExists);
+            throw new NotImplementedException();
+        }
+
+        int IFolderDao<int>.GetFolderIDUser(bool createIfNotExists, Guid? userId = null)
+        {
+            return GetFolderID(FileConstant.ModuleId, my, (userId ?? AuthContext.CurrentAccount.ID), createIfNotExists);
         }
 
         public object GetFolderIDShare(bool createIfNotExists)
@@ -847,6 +975,11 @@ namespace ASC.Files.Core.Data
             return GetFolderID(FileConstant.ModuleId, share, null, createIfNotExists);
         }
 
+        int IFolderDao<int>.GetFolderIDShare(bool createIfNotExists)
+        {
+            return GetFolderID(FileConstant.ModuleId, share, Guid.Empty, createIfNotExists);
+        }
+
         #endregion
 
         protected IQueryable<DbFolder> GetFolderQuery(Expression<Func<DbFolder, bool>> where = null)
@@ -859,7 +992,7 @@ namespace ASC.Files.Core.Data
             return q;
         }
 
-        protected List<Folder> FromQueryWithShared(IQueryable<DbFolder> dbFiles)
+        protected List<Folder<int>> FromQueryWithShared(IQueryable<DbFolder> dbFiles)
         {
             return dbFiles
                 .Select(r => new DbFolderQuery
@@ -883,7 +1016,7 @@ namespace ASC.Files.Core.Data
                 .ToList();
         }
 
-        protected List<Folder> FromQuery(IQueryable<DbFolder> dbFiles)
+        protected List<Folder<int>> FromQuery(IQueryable<DbFolder> dbFiles)
         {
             return dbFiles
                 .Select(r => new DbFolderQuery
@@ -904,9 +1037,9 @@ namespace ASC.Files.Core.Data
                 .ToList();
         }
 
-        public Folder ToFolder(DbFolderQuery r)
+        public Folder<int> ToFolder(DbFolderQuery r)
         {
-            var result = ServiceProvider.GetService<Folder>();
+            var result = ServiceProvider.GetService<Folder<int>>();
             result.ID = r.folder.Id;
             result.ParentFolderID = r.folder.ParentId;
             result.Title = r.folder.Title;
@@ -959,14 +1092,23 @@ namespace ASC.Files.Core.Data
         }
 
         public string GetBunchObjectID(object folderID)
+        {
+            throw new NotImplementedException();
+        }
+        public string GetBunchObjectID(int folderID)
         {
             return Query(FilesDbContext.BunchObjects)
-                .Where(r => r.LeftNode == (folderID ?? string.Empty).ToString())
+                .Where(r => r.LeftNode == (folderID).ToString())
                 .Select(r => r.RightNode)
                 .FirstOrDefault();
         }
 
         public Dictionary<string, string> GetBunchObjectIDs(List<object> folderIDs)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Dictionary<string, string> GetBunchObjectIDs(List<int> folderIDs)
         {
             return Query(FilesDbContext.BunchObjects)
                 .Where(r => folderIDs.Any(a => a.ToString() == r.LeftNode))

products/ASC.Files/Server/Core/Entries/ChunkedUploadSession.cs

@@ -40,23 +40,23 @@ namespace ASC.Files.Core
 {
     [DebuggerDisplay("{Id} into {FolderId}")]
     [Serializable]
-    public class ChunkedUploadSession : CommonChunkedUploadSession
+    public class ChunkedUploadSession<T> : CommonChunkedUploadSession
     {
-        public string FolderId { get; set; }
+        public T FolderId { get; set; }
 
-        public File File { get; set; }
+        public File<T> File { get; set; }
 
         public bool Encrypted { get; set; }
 
-        public ChunkedUploadSession(File file, long bytesTotal) : base(bytesTotal)
+        public ChunkedUploadSession(File<T> file, long bytesTotal) : base(bytesTotal)
         {
             File = file;
         }
 
         public override object Clone()
         {
-            var clone = (ChunkedUploadSession)MemberwiseClone();
-            clone.File = (File)File.Clone();
+            var clone = (ChunkedUploadSession<T>)MemberwiseClone();
+            clone.File = (File<T>)File.Clone();
             return clone;
         }
     }
@@ -73,7 +73,7 @@ namespace ASC.Files.Core
         }
 
 
-        public object ToResponseObject(ChunkedUploadSession session, bool appendBreadCrumbs = false)
+        public object ToResponseObject<T>(ChunkedUploadSession<T> session, bool appendBreadCrumbs = false)
         {
             var pathFolder = appendBreadCrumbs
                                  ? EntryManager.GetBreadCrumbs(session.FolderId).Select(f =>

products/ASC.Files/Server/Core/Entries/File.cs

@@ -59,6 +59,22 @@ namespace ASC.Files.Core
         [DataMember(Name = "id")]
         public new T ID { get; set; }
 
+        public new T FolderID { get; set; }
+
+        private T _folderIdDisplay;
+
+        [DataMember(Name = "folder_id")]
+        public new T FolderIdDisplay
+        {
+            get
+            {
+                if (_folderIdDisplay != null) return _folderIdDisplay;
+
+                return FolderID;
+            }
+            set { _folderIdDisplay = value; }
+        }
+
         public File(Global global, FilesLinkUtility filesLinkUtility, FileUtility fileUtility, FileConverter fileConverter) : base(global, filesLinkUtility, fileUtility, fileConverter)
         {
         }
@@ -229,6 +245,20 @@ namespace ASC.Files.Core
         public FileUtility FileUtility { get; }
         public FileConverter FileConverter { get; }
 
+        private object _folderIdDisplay;
+
+        [DataMember(Name = "folder_id")]
+        public override object FolderIdDisplay
+        {
+            get
+            {
+                if (_folderIdDisplay != null) return _folderIdDisplay;
+
+                return FolderID;
+            }
+            set { _folderIdDisplay = value; }
+        }
+
         public static string Serialize(File file)
         {
             using (var ms = new FileEntrySerializer().ToXml(file))

products/ASC.Files/Server/Core/Entries/FileEntry.cs

@@ -99,21 +99,10 @@ namespace ASC.Files.Core
         public string ProviderKey { get; set; }
 
         [DataMember(Name = "folder_id")]
-        public object FolderIdDisplay
+        public abstract object FolderIdDisplay
         {
-            get
-            {
-                if (_folderIdDisplay != null) return _folderIdDisplay;
-
-                var folder = this as Folder;
-                if (folder != null) return folder.ParentFolderID;
-
-                var file = this as File;
-                if (file != null) return file.FolderID;
-
-                return null;
-            }
-            set { _folderIdDisplay = value; }
+            get;
+            set;
         }
 
         public bool ProviderEntry
@@ -144,7 +133,6 @@ namespace ASC.Files.Core
 
         private string _modifiedByString;
         private string _createByString;
-        private object _folderIdDisplay;
 
         public override bool Equals(object obj)
         {

products/ASC.Files/Server/Core/Entries/Folder.cs

@@ -50,6 +50,32 @@ namespace ASC.Files.Core
         [EnumMember] Projects = 8
     }
 
+    public class Folder<T> : Folder
+    {
+        [DataMember(Name = "id")]
+        public new T ID { get; set; }
+
+        public new T ParentFolderID { get; set; }
+
+        private T _folderIdDisplay;
+
+        [DataMember(Name = "folder_id")]
+        public new T FolderIdDisplay
+        {
+            get
+            {
+                if (_folderIdDisplay != null) return _folderIdDisplay;
+
+                return ParentFolderID;
+            }
+            set { _folderIdDisplay = value; }
+        }
+
+        public Folder(Global global) : base(global)
+        {
+        }
+    }
+
     [DataContract(Name = "folder", Namespace = "")]
     [DebuggerDisplay("{Title} ({ID})")]
     public class Folder : FileEntry
@@ -79,6 +105,20 @@ namespace ASC.Files.Core
             set { NewForMe = Convert.ToInt32(value); }
         }
 
+        private object _folderIdDisplay;
+
+        [DataMember(Name = "folder_id")]
+        public override object FolderIdDisplay
+        {
+            get
+            {
+                if (_folderIdDisplay != null) return _folderIdDisplay;
+
+                return ParentFolderID;
+            }
+            set { _folderIdDisplay = value; }
+        }
+
         public Folder(Global global)
             : base(global)
         {

products/ASC.Files/Server/Core/FileStorageService.cs

@@ -72,7 +72,7 @@ using UrlShortener = ASC.Web.Core.Utility.UrlShortener;
 
 namespace ASC.Web.Files.Services.WCFService
 {
-    public class FileStorageService : IFileStorageService
+    public class FileStorageService //: IFileStorageService
     {
         private static readonly FileEntrySerializer serializer = new FileEntrySerializer();
         public Global Global { get; }
@@ -234,12 +234,12 @@ namespace ASC.Web.Files.Services.WCFService
             return new ItemList<object>(EntryManager.GetBreadCrumbs(folderId, folderDao).Select(f => f.ID));
         }
 
-        public DataWrapper GetFolderItems(string parentId, int from, int count, FilterType filter, bool subjectGroup, string ssubject, string searchText, bool searchInContent, bool withSubfolders, OrderBy orderBy)
+        public DataWrapper GetFolderItems<T>(string parentId, int from, int count, FilterType filter, bool subjectGroup, string ssubject, string searchText, bool searchInContent, bool withSubfolders, OrderBy orderBy)
         {
             var subjectId = string.IsNullOrEmpty(ssubject) ? Guid.Empty : new Guid(ssubject);
 
             var folderDao = GetFolderDao();
-            var fileDao = GetFileDao();
+            var fileDao = GetFileDao<T>();
 
             Folder parent = null;
             try
@@ -310,9 +310,9 @@ namespace ASC.Web.Files.Services.WCFService
             return result;
         }
 
-        public object GetFolderItemsXml(string parentId, int from, int count, FilterType filter, bool subjectGroup, string subjectID, string search, bool searchInContent, bool withSubfolders, OrderBy orderBy)
+        public object GetFolderItemsXml<T>(string parentId, int from, int count, FilterType filter, bool subjectGroup, string subjectID, string search, bool searchInContent, bool withSubfolders, OrderBy orderBy)
         {
-            var folderItems = GetFolderItems(parentId, from, count, filter, subjectGroup, subjectID, search, searchInContent, withSubfolders, orderBy);
+            var folderItems = GetFolderItems<T>(parentId, from, count, filter, subjectGroup, subjectID, search, searchInContent, withSubfolders, orderBy);
             var response = new HttpResponseMessage(HttpStatusCode.OK)
             {
                 Content = new StreamContent(serializer.ToXml(folderItems))
@@ -321,16 +321,16 @@ namespace ASC.Web.Files.Services.WCFService
             return response;
         }
 
-        public ItemList<FileEntry> GetItems(ItemList<string> items, FilterType filter, bool subjectGroup, string subjectID, string search)
+        public ItemList<FileEntry> GetItems<T>(ItemList<string> items, FilterType filter, bool subjectGroup, string subjectID, string search)
         {
-            ParseArrayItems(items, out var foldersId, out var filesId);
+            ParseArrayItems<T>(items, out var foldersId, out var filesId);
 
             var subjectId = string.IsNullOrEmpty(subjectID) ? Guid.Empty : new Guid(subjectID);
 
             var entries = Enumerable.Empty<FileEntry>();
 
-            var folderDao = GetFolderDao();
-            var fileDao = GetFileDao();
+            var folderDao = GetFolderDao<T>();
+            var fileDao = GetFileDao<T>();
             var folders = folderDao.GetFolders(foldersId.ToArray()).Cast<FileEntry>();
             folders = FileSecurity.FilterRead(folders);
             entries = entries.Concat(folders);
@@ -343,10 +343,24 @@ namespace ASC.Web.Files.Services.WCFService
 
             foreach (var fileEntry in entries)
             {
-                if (fileEntry.RootFolderType == FolderType.USER
-                    && !Equals(fileEntry.RootFolderCreator, AuthContext.CurrentAccount.ID)
-                    && !FileSecurity.CanRead(folderDao.GetFolder(fileEntry.FolderIdDisplay)))
-                    fileEntry.FolderIdDisplay = GlobalFolderHelper.FolderShare;
+                if (fileEntry is File<T> file)
+                {
+                    if (fileEntry.RootFolderType == FolderType.USER
+                        && !Equals(fileEntry.RootFolderCreator, AuthContext.CurrentAccount.ID)
+                        && !FileSecurity.CanRead(folderDao.GetFolder(file.FolderIdDisplay)))
+                    {
+                        file.FolderIdDisplay = GlobalFolderHelper.GetFolderShare<T>();
+                    }
+                }
+                else if (fileEntry is Folder<T> folder)
+                {
+                    if (fileEntry.RootFolderType == FolderType.USER
+                        && !Equals(fileEntry.RootFolderCreator, AuthContext.CurrentAccount.ID)
+                        && !FileSecurity.CanRead(folderDao.GetFolder(folder.FolderIdDisplay)))
+                    {
+                        folder.FolderIdDisplay = GlobalFolderHelper.GetFolderShare<T>();
+                    }
+                }
             }
 
             EntryManager.SetFileStatus(entries.OfType<File>().Where(r => r.ID != null).ToList());
@@ -421,9 +435,9 @@ namespace ASC.Web.Files.Services.WCFService
             return folder;
         }
 
-        public File GetFile(string fileId, int version)
+        public File<T> GetFile<T>(T fileId, int version)
         {
-            var fileDao = GetFileDao();
+            var fileDao = GetFileDao<T>();
             fileDao.InvalidateCache(fileId);
 
             var file = version > 0
@@ -439,54 +453,30 @@ namespace ASC.Web.Files.Services.WCFService
             {
                 var folderDao = GetFolderDao();
                 if (!FileSecurity.CanRead(folderDao.GetFolder(file.FolderID)))
-                    file.FolderIdDisplay = GlobalFolderHelper.FolderShare;
+                    file.FolderIdDisplay = GlobalFolderHelper.GetFolderShare<T>();
             }
 
             return file;
         }
 
-        public File<int> GetFile(int fileId, int version)
-        {
-            var fileDao = GetFileDao() as IFileDao<int>;
-            fileDao.InvalidateCache(fileId);
-
-            var file = version > 0
-                           ? fileDao.GetFile(fileId, version)
-                           : fileDao.GetFile(fileId);
-            ErrorIf(file == null, FilesCommonResource.ErrorMassage_FileNotFound);
-            ErrorIf(!FileSecurity.CanRead(file), FilesCommonResource.ErrorMassage_SecurityException_ReadFile);
-
-            EntryManager.SetFileStatus(file);
-
-            if (file.RootFolderType == FolderType.USER
-                && !Equals(file.RootFolderCreator, AuthContext.CurrentAccount.ID))
-            {
-                var folderDao = GetFolderDao();
-                if (!FileSecurity.CanRead(folderDao.GetFolder(file.FolderID)))
-                    file.FolderIdDisplay = GlobalFolderHelper.FolderShare;
-            }
-
-            return file;
-        }
-
-        public ItemList<File> GetSiblingsFile(string fileId, string parentId, FilterType filter, bool subjectGroup, string subjectID, string search, bool searchInContent, bool withSubfolders, OrderBy orderBy)
+        public ItemList<File<T>> GetSiblingsFile<T>(T fileId, T parentId, FilterType filter, bool subjectGroup, string subjectID, string search, bool searchInContent, bool withSubfolders, OrderBy orderBy)
         {
             var subjectId = string.IsNullOrEmpty(subjectID) ? Guid.Empty : new Guid(subjectID);
 
-            var fileDao = GetFileDao();
-            var folderDao = GetFolderDao();
+            var fileDao = GetFileDao<T>();
+            var folderDao = GetFolderDao<T>();
 
             var file = fileDao.GetFile(fileId);
             ErrorIf(file == null, FilesCommonResource.ErrorMassage_FileNotFound);
             ErrorIf(!FileSecurity.CanRead(file), FilesCommonResource.ErrorMassage_SecurityException_ReadFile);
 
-            var parent = folderDao.GetFolder(string.IsNullOrEmpty(parentId) ? file.FolderID : parentId);
+            var parent = folderDao.GetFolder(parentId == null || parentId.Equals(default) ? file.FolderID : parentId);
             ErrorIf(parent == null, FilesCommonResource.ErrorMassage_FolderNotFound);
             ErrorIf(parent.RootFolderType == FolderType.TRASH, FilesCommonResource.ErrorMassage_ViewTrashItem);
 
             if (filter == FilterType.FoldersOnly)
             {
-                return new ItemList<File>();
+                return new ItemList<File<T>>();
             }
             if (filter == FilterType.None)
             {
@@ -506,7 +496,7 @@ namespace ASC.Web.Files.Services.WCFService
 
             if (!FileSecurity.CanRead(parent))
             {
-                file.FolderID = GlobalFolderHelper.FolderShare;
+                file.FolderID = GlobalFolderHelper.GetFolderShare<T>();
                 entries = entries.Concat(new[] { file });
             }
             else
@@ -529,25 +519,25 @@ namespace ASC.Web.Files.Services.WCFService
 
             var result =
                 FileSecurity.FilterRead(entries)
-                            .OfType<File>()
+                            .OfType<File<T>>()
                             .Where(f => previewedType.Contains(FileUtility.GetFileTypeByFileName(f.Title)));
 
-            return new ItemList<File>(result);
+            return new ItemList<File<T>>(result);
         }
 
-        public File CreateNewFile(FileModel fileWrapper)
+        public File<T> CreateNewFile<T>(FileModel<T> fileWrapper)
         {
-            if (string.IsNullOrEmpty(fileWrapper.Title) || string.IsNullOrEmpty(fileWrapper.ParentId)) throw new ArgumentException();
+            if (string.IsNullOrEmpty(fileWrapper.Title) || fileWrapper.ParentId == null) throw new ArgumentException();
 
-            var fileDao = GetFileDao();
-            var folderDao = GetFolderDao();
+            var fileDao = GetFileDao<T>();
+            var folderDao = GetFolderDao<T>();
 
             var folder = folderDao.GetFolder(fileWrapper.ParentId);
             ErrorIf(folder == null, FilesCommonResource.ErrorMassage_FolderNotFound);
             ErrorIf(folder.RootFolderType == FolderType.TRASH, FilesCommonResource.ErrorMassage_CreateNewFolderInTrash);
             ErrorIf(!FileSecurity.CanCreate(folder), FilesCommonResource.ErrorMassage_SecurityException_Create);
 
-            var file = ServiceProvider.GetService<File>();
+            var file = ServiceProvider.GetService<File<T>>();
             file.FolderID = folder.ID;
             file.Comment = FilesCommonResource.CommentCreate;
 
@@ -622,12 +612,12 @@ namespace ASC.Web.Files.Services.WCFService
             }
         }
 
-        public ItemDictionary<string, string> CheckEditing(ItemList<string> filesId)
+        public ItemDictionary<string, string> CheckEditing<T>(ItemList<T> filesId)
         {
             ErrorIf(!AuthContext.IsAuthenticated, FilesCommonResource.ErrorMassage_SecurityException);
             var result = new ItemDictionary<string, string>();
 
-            var fileDao = GetFileDao();
+            var fileDao = GetFileDao<T>();
             var ids = filesId.Where(FileTracker.IsEditing).Select(id => id).ToArray();
 
             foreach (var file in fileDao.GetFiles(ids))
@@ -773,16 +763,16 @@ namespace ASC.Web.Files.Services.WCFService
             }
         }
 
-        public ItemList<File> GetFileHistory(string fileId)
+        public ItemList<File<T>> GetFileHistory<T>(T fileId)
         {
-            var fileDao = GetFileDao();
+            var fileDao = GetFileDao<T>();
             var file = fileDao.GetFile(fileId);
             ErrorIf(!FileSecurity.CanRead(file), FilesCommonResource.ErrorMassage_SecurityException_ReadFile);
 
-            return new ItemList<File>(fileDao.GetFileHistory(fileId));
+            return new ItemList<File<T>>(fileDao.GetFileHistory(fileId));
         }
 
-        public KeyValuePair<File, ItemList<File>> UpdateToVersion(string fileId, int version)
+        public KeyValuePair<File, ItemList<File<T>>> UpdateToVersion<T>(T fileId, int version)
         {
             var file = EntryManager.UpdateToVersionFile(fileId, version);
             FilesMessageService.Send(file, GetHttpHeaders(), MessageAction.FileRestoreVersion, file.Title, version.ToString(CultureInfo.InvariantCulture));
@@ -790,19 +780,19 @@ namespace ASC.Web.Files.Services.WCFService
             if (file.RootFolderType == FolderType.USER
                 && !Equals(file.RootFolderCreator, AuthContext.CurrentAccount.ID))
             {
-                var folderDao = GetFolderDao();
+                var folderDao = GetFolderDao<T>();
                 if (!FileSecurity.CanRead(folderDao.GetFolder(file.FolderID)))
                 {
-                    file.FolderIdDisplay = GlobalFolderHelper.FolderShare;
+                    file.FolderIdDisplay = GlobalFolderHelper.GetFolderShare<T>();
                 }
             }
 
-            return new KeyValuePair<File, ItemList<File>>(file, GetFileHistory(fileId));
+            return new KeyValuePair<File, ItemList<File<T>>>(file, GetFileHistory(fileId));
         }
 
-        public string UpdateComment(string fileId, int version, string comment)
+        public string UpdateComment<T>(T fileId, int version, string comment)
         {
-            var fileDao = GetFileDao();
+            var fileDao = GetFileDao<T>();
             var file = fileDao.GetFile(fileId, version);
             ErrorIf(file == null, FilesCommonResource.ErrorMassage_FileNotFound);
             ErrorIf(!FileSecurity.CanEdit(file) || UserManager.GetUsers(AuthContext.CurrentAccount.ID).IsVisitor(UserManager), FilesCommonResource.ErrorMassage_SecurityException_EditFile);
@@ -816,7 +806,7 @@ namespace ASC.Web.Files.Services.WCFService
             return comment;
         }
 
-        public KeyValuePair<File, ItemList<File>> CompleteVersion(string fileId, int version, bool continueVersion)
+        public KeyValuePair<File, ItemList<File<T>>> CompleteVersion<T>(T fileId, int version, bool continueVersion)
         {
             var file = EntryManager.CompleteVersionFile(fileId, version, continueVersion);
 
@@ -827,18 +817,20 @@ namespace ASC.Web.Files.Services.WCFService
             if (file.RootFolderType == FolderType.USER
                 && !Equals(file.RootFolderCreator, AuthContext.CurrentAccount.ID))
             {
-                var folderDao = GetFolderDao();
+                var folderDao = GetFolderDao<T>();
                 if (!FileSecurity.CanRead(folderDao.GetFolder(file.FolderID)))
-                    file.FolderIdDisplay = GlobalFolderHelper.FolderShare;
+                {
+                    file.FolderIdDisplay = GlobalFolderHelper.GetFolderShare<T>();
+                }
             }
 
-            return new KeyValuePair<File, ItemList<File>>(file, GetFileHistory(fileId));
+            return new KeyValuePair<File, ItemList<File<T>>>(file, GetFileHistory(fileId));
         }
 
-        public File LockFile(string fileId, bool lockfile)
+        public File<T> LockFile<T>(T fileId, bool lockfile)
         {
             var tagDao = GetTagDao();
-            var fileDao = GetFileDao();
+            var fileDao = GetFileDao<T>();
             var file = fileDao.GetFile(fileId);
 
             ErrorIf(file == null, FilesCommonResource.ErrorMassage_FileNotFound);
@@ -892,17 +884,19 @@ namespace ASC.Web.Files.Services.WCFService
             if (file.RootFolderType == FolderType.USER
                 && !Equals(file.RootFolderCreator, AuthContext.CurrentAccount.ID))
             {
-                var folderDao = GetFolderDao();
+                var folderDao = GetFolderDao<T>();
                 if (!FileSecurity.CanRead(folderDao.GetFolder(file.FolderID)))
-                    file.FolderIdDisplay = GlobalFolderHelper.FolderShare;
+                {
+                    file.FolderIdDisplay = GlobalFolderHelper.GetFolderShare<T>();
+                }
             }
 
             return file;
         }
 
-        public ItemList<EditHistory> GetEditHistory(string fileId, string doc = null)
+        public ItemList<EditHistory> GetEditHistory<T>(T fileId, string doc = null)
         {
-            var fileDao = GetFileDao();
+            var fileDao = GetFileDao<T>();
             var readLink = FileShareLink.Check(doc, true, fileDao, out var file);
             if (file == null)
                 file = fileDao.GetFile(fileId);
@@ -914,14 +908,14 @@ namespace ASC.Web.Files.Services.WCFService
             return new ItemList<EditHistory>(fileDao.GetEditHistory(DocumentServiceHelper, file.ID));
         }
 
-        public EditHistoryData GetEditDiffUrl(string fileId, int version = 0, string doc = null)
+        public EditHistoryData GetEditDiffUrl<T>(T fileId, int version = 0, string doc = null)
         {
-            var fileDao = GetFileDao();
+            var fileDao = GetFileDao<T>();
             var readLink = FileShareLink.Check(doc, true, fileDao, out var file);
 
             if (file != null)
             {
-                fileId = file.ID.ToString();
+                fileId = file.ID;
             }
 
             if (file == null
@@ -990,10 +984,10 @@ namespace ASC.Web.Files.Services.WCFService
             return result;
         }
 
-        public ItemList<EditHistory> RestoreVersion(string fileId, int version, string url = null, string doc = null)
+        public ItemList<EditHistory> RestoreVersion<T>(T fileId, int version, string url = null, string doc = null)
         {
-            IFileDao fileDao;
-            File file;
+            IFileDao<T> fileDao;
+            File<T> file;
             if (string.IsNullOrEmpty(url))
             {
                 file = EntryManager.UpdateToVersionFile(fileId, version, doc);
@@ -1001,7 +995,7 @@ namespace ASC.Web.Files.Services.WCFService
             else
             {
                 string modifiedOnString;
-                fileDao = GetFileDao();
+                fileDao = GetFileDao<T>();
                 var fromFile = fileDao.GetFile(fileId, version);
                 modifiedOnString = fromFile.ModifiedOnString;
                 file = EntryManager.SaveEditing(fileId, null, url, null, doc, string.Format(FilesCommonResource.CommentRevertChanges, modifiedOnString));
@@ -1009,7 +1003,7 @@ namespace ASC.Web.Files.Services.WCFService
 
             FilesMessageService.Send(file, GetHttpHeaders(), MessageAction.FileRestoreVersion, file.Title, version.ToString(CultureInfo.InvariantCulture));
 
-            fileDao = GetFileDao();
+            fileDao = GetFileDao<T>();
             return new ItemList<EditHistory>(fileDao.GetEditHistory(DocumentServiceHelper, file.ID));
         }
 
@@ -1027,7 +1021,7 @@ namespace ASC.Web.Files.Services.WCFService
             return result;
         }
 
-        public object GetNewItems(string folderId)
+        public object GetNewItems<T>(string folderId)
         {
             try
             {
@@ -1041,7 +1035,7 @@ namespace ASC.Web.Files.Services.WCFService
 
                 if (!result.ToList().Any())
                 {
-                    MarkAsRead(new ItemList<string> { "folder_" + folderId });
+                    MarkAsRead<T>(new ItemList<string> { "folder_" + folderId });
                 }
 
                 var response = new HttpResponseMessage(HttpStatusCode.OK)
@@ -1057,11 +1051,11 @@ namespace ASC.Web.Files.Services.WCFService
             }
         }
 
-        public ItemList<FileOperationResult> MarkAsRead(ItemList<string> items)
+        public ItemList<FileOperationResult> MarkAsRead<T>(ItemList<string> items)
         {
             if (items.Count == 0) return GetTasksStatuses();
 
-            ParseArrayItems(items, out var foldersId, out var filesId);
+            ParseArrayItems<T>(items, out var foldersId, out var filesId);
 
             return FileOperationsManagerHelper.MarkAsRead(foldersId, filesId);
         }
@@ -1269,20 +1263,20 @@ namespace ASC.Web.Files.Services.WCFService
             return FileOperationsManagerHelper.Download(folders, files, GetHttpHeaders());
         }
 
-        public ItemDictionary<string, string> MoveOrCopyFilesCheck(ItemList<string> items, string destFolderId)
+        public ItemDictionary<string, string> MoveOrCopyFilesCheck<T>(ItemList<string> items, T destFolderId)
         {
             if (items.Count == 0) return new ItemDictionary<string, string>();
 
-            ParseArrayItems(items, out var foldersId, out var filesId);
+            ParseArrayItems<T>(items, out var foldersId, out var filesId);
 
             return new ItemDictionary<string, string>(MoveOrCopyFilesCheck(filesId, foldersId, destFolderId));
         }
 
-        private Dictionary<string, string> MoveOrCopyFilesCheck(IEnumerable<object> filesId, IEnumerable<object> foldersId, object destFolderId)
+        private Dictionary<string, string> MoveOrCopyFilesCheck<T>(IEnumerable<T> filesId, IEnumerable<T> foldersId, T destFolderId)
         {
             var result = new Dictionary<string, string>();
-            var folderDao = GetFolderDao();
-            var fileDao = GetFileDao();
+            var folderDao = GetFolderDao<T>();
+            var fileDao = GetFileDao<T>();
 
             var toFolder = folderDao.GetFolder(destFolderId);
             ErrorIf(toFolder == null, FilesCommonResource.ErrorMassage_FolderNotFound);
@@ -1332,14 +1326,14 @@ namespace ASC.Web.Files.Services.WCFService
             return result;
         }
 
-        public ItemList<FileOperationResult> MoveOrCopyItems(ItemList<string> items, string destFolderId, FileConflictResolveType resolve, bool ic, bool deleteAfter = false)
+        public ItemList<FileOperationResult> MoveOrCopyItems<T>(ItemList<string> items, T destFolderId, FileConflictResolveType resolve, bool ic, bool deleteAfter = false)
         {
             ItemList<FileOperationResult> result;
             if (items.Count != 0)
             {
-                ParseArrayItems(items, out var foldersId, out var filesId);
+                ParseArrayItems<T>(items, out var foldersId, out var filesId);
 
-                result = FileOperationsManagerHelper.MoveOrCopy(foldersId, filesId, destFolderId, ic, resolve, !deleteAfter, GetHttpHeaders());
+                result = FileOperationsManagerHelper.MoveOrCopy<T>(foldersId, filesId, destFolderId, ic, resolve, !deleteAfter, GetHttpHeaders());
             }
             else
             {
@@ -1348,17 +1342,17 @@ namespace ASC.Web.Files.Services.WCFService
             return result;
         }
 
-        public ItemList<FileOperationResult> DeleteItems(string action, ItemList<string> items, bool ignoreException = false, bool deleteAfter = false, bool immediately = false)
+        public ItemList<FileOperationResult> DeleteItems<T>(string action, ItemList<string> items, bool ignoreException = false, bool deleteAfter = false, bool immediately = false)
         {
-            ParseArrayItems(items, out var foldersId, out var filesId);
+            ParseArrayItems<T>(items, out var foldersId, out var filesId);
 
             return FileOperationsManagerHelper.Delete(foldersId, filesId, ignoreException, !deleteAfter, immediately, GetHttpHeaders());
         }
 
-        public ItemList<FileOperationResult> EmptyTrash()
+        public ItemList<FileOperationResult> EmptyTrash<T>()
         {
-            var folderDao = GetFolderDao();
-            var fileDao = GetFileDao();
+            var folderDao = GetFolderDao<T>();
+            var fileDao = GetFileDao<T>();
             var trashId = folderDao.GetFolderIDTrash(true);
             var foldersId = folderDao.GetFolders(trashId).Select(f => f.ID).ToList();
             var filesId = fileDao.GetFiles(trashId).ToList();
@@ -1366,22 +1360,15 @@ namespace ASC.Web.Files.Services.WCFService
             return FileOperationsManagerHelper.Delete(foldersId, filesId, false, true, false, GetHttpHeaders());
         }
 
-        public ItemList<FileOperationResult> CheckConversion(ItemList<ItemList<string>> filesInfoJSON)
+        public ItemList<FileOperationResult> CheckConversion<T>(ItemList<ItemList<string>> filesInfoJSON)
         {
             if (filesInfoJSON == null || filesInfoJSON.Count == 0) return new ItemList<FileOperationResult>();
 
-            var fileDao = GetFileDao();
-            var files = new List<KeyValuePair<File, bool>>();
+            var fileDao = GetFileDao<T>();
+            var files = new List<KeyValuePair<File<T>, bool>>();
             foreach (var fileInfo in filesInfoJSON)
             {
-                object fileId;
-
-                var fileIdAsString = fileInfo[0];
-
-                if (int.TryParse(fileIdAsString, out var fileIdAsInt))
-                    fileId = fileIdAsInt;
-                else
-                    fileId = fileIdAsString;
+                var fileId = (T)Convert.ChangeType(fileInfo[0], typeof(T));
 
                 var file = int.TryParse(fileInfo[1], out var version) && version > 0
                                 ? fileDao.GetFile(fileId, version)
@@ -1389,11 +1376,11 @@ namespace ASC.Web.Files.Services.WCFService
 
                 if (file == null)
                 {
-                    var newFile = ServiceProvider.GetService<File>();
+                    var newFile = ServiceProvider.GetService<File<T>>();
                     newFile.ID = fileId;
                     newFile.Version = version;
 
-                    files.Add(new KeyValuePair<File, bool>(newFile, true));
+                    files.Add(new KeyValuePair<File<T>, bool>(newFile, true));
                     continue;
                 }
 
@@ -1412,7 +1399,7 @@ namespace ASC.Web.Files.Services.WCFService
                     }
                 }
 
-                files.Add(new KeyValuePair<File, bool>(file, false));
+                files.Add(new KeyValuePair<File<T>, bool>(file, false));
             }
 
             var results = FileConverter.GetStatus(files).ToList();
@@ -1420,7 +1407,7 @@ namespace ASC.Web.Files.Services.WCFService
             return new ItemList<FileOperationResult>(results);
         }
 
-        public void ReassignStorage(Guid userFromId, Guid userToId)
+        public void ReassignStorage<T>(Guid userFromId, Guid userToId)
         {
             //check current user have access
             ErrorIf(!Global.IsAdministrator, FilesCommonResource.ErrorMassage_SecurityException);
@@ -1448,8 +1435,8 @@ namespace ASC.Web.Files.Services.WCFService
                 }
             }
 
-            var folderDao = GetFolderDao();
-            var fileDao = GetFileDao();
+            var folderDao = GetFolderDao<T>();
+            var fileDao = GetFileDao<T>();
 
             if (!userFrom.IsVisitor(UserManager))
             {
@@ -1459,7 +1446,7 @@ namespace ASC.Web.Files.Services.WCFService
                 {
                     //create folder with name userFrom in folder userTo
                     var folderIdToMy = folderDao.GetFolderIDUser(true, userTo.ID);
-                    var newFolder = ServiceProvider.GetService<Folder>();
+                    var newFolder = ServiceProvider.GetService<Folder<T>>();
                     newFolder.Title = string.Format(CustomNamingPeople.Substitute<FilesCommonResource>("TitleDeletedUserFolder"), userFrom.DisplayUserName(false, DisplayUserSettingsHelper));
                     newFolder.ParentFolderID = folderIdToMy;
 
@@ -1472,10 +1459,10 @@ namespace ASC.Web.Files.Services.WCFService
                 }
             }
 
-            EntryManager.ReassignItems(GlobalFolderHelper.FolderCommon, userFrom.ID, userTo.ID, folderDao, fileDao);
+            EntryManager.ReassignItems(GlobalFolderHelper.GetFolderCommon<T>(), userFrom.ID, userTo.ID, folderDao, fileDao);
         }
 
-        public void DeleteStorage(Guid userId)
+        public void DeleteStorage<T>(Guid userId)
         {
             //check current user have access
             ErrorIf(!Global.IsAdministrator, FilesCommonResource.ErrorMassage_SecurityException);
@@ -1496,15 +1483,15 @@ namespace ASC.Web.Files.Services.WCFService
                 }
             }
 
-            var folderDao = GetFolderDao();
-            var fileDao = GetFileDao();
+            var folderDao = GetFolderDao<T>();
+            var fileDao = GetFileDao<T>();
 
             //delete all markAsNew
-            var rootFoldersId = new List<object>
+            var rootFoldersId = new List<T>
                 {
-                    GlobalFolderHelper.FolderShare,
-                    GlobalFolderHelper.FolderCommon,
-                    GlobalFolderHelper.FolderProjects,
+                    GlobalFolderHelper.GetFolderShare<T>(),
+                    GlobalFolderHelper.GetFolderCommon<T>(),
+                    GlobalFolderHelper.GetFolderProjects<T>(),
                 };
 
             var folderIdFromMy = folderDao.GetFolderIDUser(false, userId);
@@ -1533,12 +1520,12 @@ namespace ASC.Web.Files.Services.WCFService
             var folderIdFromTrash = folderDao.GetFolderIDTrash(false, userId);
             if (!Equals(folderIdFromTrash, 0))
             {
-                EntryManager.DeleteSubitems(folderIdFromTrash, folderDao, fileDao);
+                EntryManager.DeleteSubitems<T>(folderIdFromTrash, folderDao, fileDao);
                 folderDao.DeleteFolder(folderIdFromTrash);
                 GlobalFolderHelper.FolderTrash = userId;
             }
 
-            EntryManager.ReassignItems(GlobalFolderHelper.FolderCommon, userId, AuthContext.CurrentAccount.ID, folderDao, fileDao);
+            EntryManager.ReassignItems<T>(GlobalFolderHelper.GetFolderCommon<T>(), userId, AuthContext.CurrentAccount.ID, folderDao, fileDao);
         }
 
         public ItemList<AceWrapper> GetSharedInfo(ItemList<string> objectIds)
@@ -1551,16 +1538,16 @@ namespace ASC.Web.Files.Services.WCFService
             return FileSharing.GetSharedInfoShort(objectId);
         }
 
-        public ItemList<string> SetAceObject(AceCollection aceCollection, bool notify)
+        public ItemList<string> SetAceObject<T>(AceCollection aceCollection, bool notify)
         {
-            var fileDao = GetFileDao();
+            var fileDao = GetFileDao<T>();
             var folderDao = GetFolderDao();
             var result = new ItemList<string>();
             foreach (var objectId in aceCollection.Entries)
             {
                 Debug.Assert(objectId != null, "objectId != null");
                 var entryType = objectId.StartsWith("file_") ? FileEntryType.File : FileEntryType.Folder;
-                var entryId = objectId.Substring((entryType == FileEntryType.File ? "file_" : "folder_").Length);
+                var entryId = (T)Convert.ChangeType(objectId.Substring((entryType == FileEntryType.File ? "file_" : "folder_").Length), typeof(T));
                 var entry = entryType == FileEntryType.File
                                 ? (FileEntry)fileDao.GetFile(entryId)
                                 : (FileEntry)folderDao.GetFolder(entryId);
@@ -1589,25 +1576,25 @@ namespace ASC.Web.Files.Services.WCFService
             return result;
         }
 
-        public void RemoveAce(ItemList<string> items)
+        public void RemoveAce<T>(ItemList<string> items)
         {
             ErrorIf(!AuthContext.IsAuthenticated, FilesCommonResource.ErrorMassage_SecurityException);
-            ParseArrayItems(items, out var foldersId, out var filesId);
+            ParseArrayItems<T>(items, out var foldersId, out var filesId);
 
             var entries = new List<FileEntry>();
 
-            var fileDao = GetFileDao();
-            var folderDao = GetFolderDao();
+            var fileDao = GetFileDao<T>();
+            var folderDao = GetFolderDao<T>();
             entries.AddRange(filesId.Select(fileId => fileDao.GetFile(fileId)));
             entries.AddRange(foldersId.Select(folderDao.GetFolder));
 
             FileSharingAceHelper.RemoveAce(entries);
         }
 
-        public string GetShortenLink(string fileId)
+        public string GetShortenLink<T>(T fileId)
         {
-            File file;
-            var fileDao = GetFileDao();
+            File<T> file;
+            var fileDao = GetFileDao<T>();
             file = fileDao.GetFile(fileId);
             ErrorIf(!FileSharing.CanSetAccess(file), FilesCommonResource.ErrorMassage_SecurityException);
             var shareLink = FileShareLink.GetLink(file);
@@ -1622,10 +1609,10 @@ namespace ASC.Web.Files.Services.WCFService
             }
         }
 
-        public bool SetAceLink(string fileId, FileShare share)
+        public bool SetAceLink<T>(T fileId, FileShare share)
         {
             FileEntry file;
-            var fileDao = GetFileDao();
+            var fileDao = GetFileDao<T>();
             file = fileDao.GetFile(fileId);
             var aces = new List<AceWrapper>
                 {
@@ -1655,13 +1642,13 @@ namespace ASC.Web.Files.Services.WCFService
             return securityDao.IsShared(file.ID, FileEntryType.File);
         }
 
-        public ItemList<MentionWrapper> SharedUsers(string fileId)
+        public ItemList<MentionWrapper> SharedUsers<T>(T fileId)
         {
             if (!AuthContext.IsAuthenticated || CoreBaseSettings.Personal)
                 return null;
 
             FileEntry file;
-            var fileDao = GetFileDao();
+            var fileDao = GetFileDao<T>();
             file = fileDao.GetFile(fileId);
 
             ErrorIf(file == null, FilesCommonResource.ErrorMassage_FileNotFound);
@@ -1693,12 +1680,12 @@ namespace ASC.Web.Files.Services.WCFService
             return new ItemList<MentionWrapper>(users);
         }
 
-        public ItemList<AceShortWrapper> SendEditorNotify(string fileId, MentionMessageWrapper mentionMessage)
+        public ItemList<AceShortWrapper> SendEditorNotify<T>(T fileId, MentionMessageWrapper mentionMessage)
         {
             ErrorIf(!AuthContext.IsAuthenticated, FilesCommonResource.ErrorMassage_SecurityException);
 
-            File file;
-            var fileDao = GetFileDao();
+            File<T> file;
+            var fileDao = GetFileDao<T>();
             file = fileDao.GetFile(fileId);
 
             ErrorIf(file == null, FilesCommonResource.ErrorMassage_FileNotFound);
@@ -1813,12 +1800,12 @@ namespace ASC.Web.Files.Services.WCFService
             //return new ItemList<string>(accounts);
         }
 
-        public ItemList<FileEntry> ChangeOwner(ItemList<string> items, Guid userId)
+        public ItemList<FileEntry> ChangeOwner<T>(ItemList<string> items, Guid userId)
         {
             var userInfo = UserManager.GetUsers(userId);
             ErrorIf(Equals(userInfo, Constants.LostUser) || userInfo.IsVisitor(UserManager), FilesCommonResource.ErrorMassage_ChangeOwner);
 
-            ParseArrayItems(items, out var foldersId, out var filesId);
+            ParseArrayItems<T>(items, out var foldersId, out var filesId);
 
             var entries = new List<FileEntry>();
 
@@ -1847,7 +1834,7 @@ namespace ASC.Web.Files.Services.WCFService
                 entries.Add(newFolder);
             }
 
-            var fileDao = GetFileDao();
+            var fileDao = GetFileDao<T>();
             var files = fileDao.GetFiles(filesId.ToArray());
 
             foreach (var file in files)
@@ -1861,7 +1848,7 @@ namespace ASC.Web.Files.Services.WCFService
                 var newFile = file;
                 if (file.CreateBy != userInfo.ID)
                 {
-                    newFile = ServiceProvider.GetService<File>();
+                    newFile = ServiceProvider.GetService<File<T>>();
                     newFile.ID = file.ID;
                     newFile.Version = file.Version + 1;
                     newFile.VersionGroup = file.VersionGroup + 1;
@@ -1957,9 +1944,14 @@ namespace ASC.Web.Files.Services.WCFService
             return DaoFactory.FolderDao;
         }
 
-        private IFileDao GetFileDao()
+        private IFolderDao<T> GetFolderDao<T>()
         {
-            return DaoFactory.FileDao;
+            return DaoFactory.GetFolderDao<T>();
+        }
+
+        private IFileDao<T> GetFileDao<T>()
+        {
+            return DaoFactory.GetFileDao<T>();
         }
 
         private ITagDao GetTagDao()
@@ -1982,15 +1974,15 @@ namespace ASC.Web.Files.Services.WCFService
             return DaoFactory.SecurityDao;
         }
 
-        private static void ParseArrayItems(IEnumerable<string> data, out List<object> foldersId, out List<object> filesId)
+        private static void ParseArrayItems<T>(IEnumerable<string> data, out List<T> foldersId, out List<T> filesId)
         {
             //TODO:!!!!Fix
-            foldersId = new List<object>();
-            filesId = new List<object>();
+            foldersId = new List<T>();
+            filesId = new List<T>();
             foreach (var id in data)
             {
-                if (id.StartsWith("file_")) filesId.Add(id.Substring("file_".Length));
-                if (id.StartsWith("folder_")) foldersId.Add(id.Substring("folder_".Length));
+                if (id.StartsWith("file_")) filesId.Add((T)Convert.ChangeType(id.Substring("file_".Length), typeof(T)));
+                if (id.StartsWith("folder_")) foldersId.Add((T)Convert.ChangeType(id.Substring("folder_".Length), typeof(T)));
             }
         }
 
@@ -2044,7 +2036,7 @@ namespace ASC.Web.Files.Services.WCFService
         public static DIHelper AddFileStorageService(this DIHelper services)
         {
             services.TryAddScoped<FileStorageService>();
-            services.TryAddScoped<IFileStorageService, FileStorageService>();
+            //services.TryAddScoped<IFileStorageService, FileStorageService>();
             return services
                 .AddGlobalService()
                 .AddGlobalStoreService()
@@ -2085,9 +2077,9 @@ namespace ASC.Web.Files.Services.WCFService
         }
     }
 
-    public class FileModel
+    public class FileModel<T>
     {
-        public string ParentId { get; set; }
+        public T ParentId { get; set; }
         public string Title { get; set; }
     }
 }

products/ASC.Files/Server/Core/Security/FileSecurity.cs

@@ -290,11 +290,21 @@ namespace ASC.Files.Core.Security
             return Filter(entries.Cast<FileEntry>(), FilesSecurityActions.Read, AuthContext.CurrentAccount.ID).Cast<File>();
         }
 
+        public IEnumerable<File<T>> FilterRead<T>(IEnumerable<File<T>> entries)
+        {
+            return Filter(entries.Cast<FileEntry>(), FilesSecurityActions.Read, AuthContext.CurrentAccount.ID).Cast<File<T>>();
+        }
+
         public IEnumerable<Folder> FilterRead(IEnumerable<Folder> entries)
         {
             return Filter(entries.Cast<FileEntry>(), FilesSecurityActions.Read, AuthContext.CurrentAccount.ID).Cast<Folder>();
         }
 
+        public IEnumerable<Folder<T>> FilterRead<T>(IEnumerable<Folder<T>> entries)
+        {
+            return Filter(entries.Cast<FileEntry>(), FilesSecurityActions.Read, AuthContext.CurrentAccount.ID).Cast<Folder<T>>();
+        }
+
         public IEnumerable<File> FilterEdit(IEnumerable<File> entries)
         {
             return Filter(entries.Cast<FileEntry>(), FilesSecurityActions.Edit, AuthContext.CurrentAccount.ID).Cast<File>();

products/ASC.Files/Server/Helpers/Global.cs

@@ -299,6 +299,23 @@ namespace ASC.Web.Files.Classes
             return result;
         }
 
+        public T GetFolderProjects<T>(IDaoFactory daoFactory)
+        {
+            if (CoreBaseSettings.Personal) return default;
+
+            if (WebItemManager[WebItemManager.ProjectsProductID].IsDisabled(WebItemSecurity, AuthContext)) return default;
+
+            var folderDao = daoFactory.GetFolderDao<T>();
+            if (!ProjectsRootFolderCache.TryGetValue(TenantManager.GetCurrentTenant().TenantId, out var result))
+            {
+                result = folderDao.GetFolderIDProjects(true);
+
+                ProjectsRootFolderCache[TenantManager.GetCurrentTenant().TenantId] = result;
+            }
+
+            return (T)result;
+        }
+
         internal static readonly IDictionary<string, object> UserRootFolderCache =
             new ConcurrentDictionary<string, object>(); /*Use SYNCHRONIZED for cross thread blocks*/
 
@@ -339,6 +356,18 @@ namespace ASC.Web.Files.Classes
             }
             return commonFolderId;
         }
+        public T GetFolderCommon<T>(FileMarker fileMarker, IDaoFactory daoFactory)
+        {
+            if (CoreBaseSettings.Personal) return default;
+
+            if (!CommonFolderCache.TryGetValue(TenantManager.GetCurrentTenant().TenantId, out var commonFolderId))
+            {
+                commonFolderId = GetFolderIdAndProccessFirstVisit<T>(fileMarker, daoFactory, false);
+                if (!Equals(commonFolderId, 0))
+                    CommonFolderCache[TenantManager.GetCurrentTenant().TenantId] = commonFolderId;
+            }
+            return (T)commonFolderId;
+        }
 
         internal static readonly IDictionary<int, object> ShareFolderCache =
             new ConcurrentDictionary<int, object>(); /*Use SYNCHRONIZED for cross thread blocks*/
@@ -359,6 +388,22 @@ namespace ASC.Web.Files.Classes
             return sharedFolderId;
         }
 
+        public T GetFolderShare<T>(IFolderDao<T> folderDao)
+        {
+            if (CoreBaseSettings.Personal) return default;
+            if (IsOutsider) return default;
+
+            if (!ShareFolderCache.TryGetValue(TenantManager.GetCurrentTenant().TenantId, out var sharedFolderId))
+            {
+                sharedFolderId = folderDao.GetFolderIDShare(true);
+
+                if (!sharedFolderId.Equals(default))
+                    ShareFolderCache[TenantManager.GetCurrentTenant().TenantId] = sharedFolderId;
+            }
+
+            return (T)sharedFolderId;
+        }
+
         internal static readonly IDictionary<string, object> TrashFolderCache =
             new ConcurrentDictionary<string, object>(); /*Use SYNCHRONIZED for cross thread blocks*/
 
@@ -382,6 +427,42 @@ namespace ASC.Web.Files.Classes
             TrashFolderCache.Remove(cacheKey);
         }
 
+        private T GetFolderIdAndProccessFirstVisit<T>(FileMarker fileMarker, IDaoFactory daoFactory, bool my)
+        {
+            var folderDao = daoFactory.GetFolderDao<T>();
+            var fileDao = daoFactory.GetFileDao<T>();
+
+            var id = my ? folderDao.GetFolderIDUser(false) : folderDao.GetFolderIDCommon(false);
+
+            if (Equals(id, 0)) //TODO: think about 'null'
+            {
+                id = my ? folderDao.GetFolderIDUser(true) : folderDao.GetFolderIDCommon(true);
+
+                //Copy start document
+                if (AdditionalWhiteLabelSettings.Instance(SettingsManager).StartDocsEnabled)
+                {
+                    try
+                    {
+                        var storeTemplate = GlobalStore.GetStoreTemplate();
+
+                        var culture = my ? UserManager.GetUsers(AuthContext.CurrentAccount.ID).GetCulture() : TenantManager.GetCurrentTenant().GetCulture();
+                        var path = FileConstant.StartDocPath + culture + "/";
+
+                        if (!storeTemplate.IsDirectory(path))
+                            path = FileConstant.StartDocPath + "default/";
+                        path += my ? "my/" : "corporate/";
+
+                        SaveStartDocument(fileMarker, folderDao, fileDao, id, path, storeTemplate);
+                    }
+                    catch (Exception ex)
+                    {
+                        Logger.Error(ex);
+                    }
+                }
+            }
+
+            return id;
+        }
         private object GetFolderIdAndProccessFirstVisit(FileMarker fileMarker, IDaoFactory daoFactory, bool my)
         {
             var folderDao = daoFactory.FolderDao;
@@ -438,6 +519,25 @@ namespace ASC.Web.Files.Classes
             }
         }
 
+        private void SaveStartDocument<T>(FileMarker fileMarker, IFolderDao<T> folderDao, IFileDao<T> fileDao, T folderId, string path, IDataStore storeTemplate)
+        {
+            foreach (var file in storeTemplate.ListFilesRelative("", path, "*", false))
+            {
+                SaveFile(fileMarker, fileDao, folderId, path + file, storeTemplate);
+            }
+
+            foreach (var folderName in storeTemplate.ListDirectoriesRelative(path, false))
+            {
+                var folder = ServiceProvider.GetService<Folder<T>>();
+                folder.Title = folderName;
+                folder.ParentFolderID = folderId;
+
+                var subFolderId = folderDao.SaveFolder(folder);
+
+                SaveStartDocument(fileMarker, folderDao, fileDao, subFolderId, path + folderName + "/", storeTemplate);
+            }
+        }
+
         private void SaveFile(FileMarker fileMarker, IFileDao fileDao, object folder, string filePath, IDataStore storeTemp)
         {
             using var stream = storeTemp.GetReadStream("", filePath);
@@ -461,6 +561,31 @@ namespace ASC.Web.Files.Classes
                 Logger.Error(ex);
             }
         }
+
+        private void SaveFile<T>(FileMarker fileMarker, IFileDao<T> fileDao, T folder, string filePath, IDataStore storeTemp)
+        {
+            using var stream = storeTemp.GetReadStream("", filePath);
+            var fileName = Path.GetFileName(filePath);
+            var file = ServiceProvider.GetService<File<T>>();
+
+            file.Title = fileName;
+            file.ContentLength = stream.CanSeek ? stream.Length : storeTemp.GetFileSize("", filePath);
+            file.FolderID = folder;
+            file.Comment = FilesCommonResource.CommentCreate;
+
+            stream.Position = 0;
+            try
+            {
+                file = fileDao.SaveFile(file, stream);
+
+                fileMarker.MarkAsNew(file);
+            }
+            catch (Exception ex)
+            {
+                Logger.Error(ex);
+            }
+        }
+
         public bool IsOutsider
         {
             get { return UserManager.GetUsers(AuthContext.CurrentAccount.ID).IsOutsider(UserManager); }
@@ -487,6 +612,11 @@ namespace ASC.Web.Files.Classes
                 return GlobalFolder.GetFolderProjects(DaoFactory);
             }
         }
+        public T GetFolderProjects<T>()
+        {
+            return GlobalFolder.GetFolderProjects<T>(DaoFactory);
+        }
+
         public object FolderCommon
         {
             get
@@ -495,6 +625,11 @@ namespace ASC.Web.Files.Classes
             }
         }
 
+        public T GetFolderCommon<T>()
+        {
+            return GlobalFolder.GetFolderCommon<T>(FileMarker, DaoFactory);
+        }
+
         public object FolderMy
         {
             get
@@ -515,6 +650,11 @@ namespace ASC.Web.Files.Classes
             }
         }
 
+        public T GetFolderShare<T>()
+        {
+            return GlobalFolder.GetFolderShare(DaoFactory.GetFolderDao<T>());
+        }
+
         public object FolderTrash
         {
             get

products/ASC.Files/Server/HttpHandlers/ChunkedUploaderHandler.cs

@@ -118,7 +118,7 @@ namespace ASC.Web.Files.HttpHandlers
                 switch (request.Type(InstanceCrypto))
                 {
                     case ChunkedRequestType.Abort:
-                        FileUploader.AbortUpload(request.UploadId);
+                        FileUploader.AbortUpload<string>(request.UploadId);
                         WriteSuccess(context, null);
                         return;
 
@@ -128,7 +128,7 @@ namespace ASC.Web.Files.HttpHandlers
                         return;
 
                     case ChunkedRequestType.Upload:
-                        var resumedSession = FileUploader.UploadChunk(request.UploadId, request.ChunkStream, request.ChunkSize);
+                        var resumedSession = FileUploader.UploadChunk<string>(request.UploadId, request.ChunkStream, request.ChunkSize);
 
                         if (resumedSession.BytesUploaded == resumedSession.BytesTotal)
                         {
@@ -174,7 +174,7 @@ namespace ASC.Web.Files.HttpHandlers
 
             if (!string.IsNullOrEmpty(request.UploadId))
             {
-                var uploadSession = ChunkedUploadSessionHolder.GetSession(request.UploadId);
+                var uploadSession = ChunkedUploadSessionHolder.GetSession<string>(request.UploadId);
                 if (uploadSession != null)
                 {
                     TenantManager.SetCurrentTenant(uploadSession.TenantId);

products/ASC.Files/Server/HttpHandlers/FileHandler.ashx.cs

@@ -38,7 +38,6 @@ using ASC.Common.Logging;
 using ASC.Common.Web;
 using ASC.Core;
 using ASC.Files.Core;
-using ASC.Files.Core.Data;
 using ASC.Files.Core.Security;
 using ASC.Files.Resources;
 using ASC.MessagingSystem;
@@ -266,14 +265,27 @@ namespace ASC.Web.Files
         }
 
         private void DownloadFile(HttpContext context)
+        {
+            var q = context.Request.Query[FilesLinkUtility.FileId];
+
+            if (int.TryParse(q, out var id))
+            {
+                DownloadFile(context, id);
+            }
+            else
+            {
+                DownloadFile(context, q);
+            }
+        }
+
+        private void DownloadFile<T>(HttpContext context, T id)
         {
             var flushed = false;
             try
             {
-                var id = context.Request.Query[FilesLinkUtility.FileId];
                 var doc = context.Request.Query[FilesLinkUtility.DocShareKey].FirstOrDefault() ?? "";
 
-                var fileDao = DaoFactory.FileDao;
+                var fileDao = DaoFactory.GetFileDao<T>();
                 var readLink = FileShareLink.Check(doc, true, fileDao, out var file);
                 if (!readLink && file == null)
                 {
@@ -352,7 +364,7 @@ namespace ASC.Web.Files
                                 && FFmpegService.IsConvertable(ext))
                             {
                                 const string mp4Name = "content.mp4";
-                                var mp4Path = FileDao.GetUniqFilePath(file, mp4Name);
+                                var mp4Path = fileDao.GetUniqFilePath(file, mp4Name);
                                 var store = GlobalStore.GetStore();
                                 if (!store.IsFile(mp4Path))
                                 {

products/ASC.Files/Server/Services/WCFService/FileOperations/FileDeleteOperation.cs

@@ -39,13 +39,13 @@ using Microsoft.Extensions.DependencyInjection;
 
 namespace ASC.Web.Files.Services.WCFService.FileOperations
 {
-    internal class FileDeleteOperationData : FileOperationData
+    internal class FileDeleteOperationData<T> : FileOperationData<T>
     {
         public bool IgnoreException { get; }
         public bool Immediately { get; }
         public Dictionary<string, string> Headers { get; }
 
-        public FileDeleteOperationData(List<object> folders, List<object> files, Tenant tenant,
+        public FileDeleteOperationData(List<T> folders, List<T> files, Tenant tenant,
             bool holdResult = true, bool ignoreException = false, bool immediately = false, Dictionary<string, string> headers = null)
             : base(folders, files, tenant, holdResult)
         {
@@ -55,9 +55,9 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
         }
     }
 
-    class FileDeleteOperation : FileOperation<FileDeleteOperationData>
+    class FileDeleteOperation<T> : FileOperation<FileDeleteOperationData<T>, T>
     {
-        private object _trashId;
+        private T _trashId;
         private readonly bool _ignoreException;
         private readonly bool _immediately;
         private readonly Dictionary<string, string> _headers;
@@ -68,7 +68,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
         }
 
 
-        public FileDeleteOperation(IServiceProvider serviceProvider, FileDeleteOperationData fileOperationData)
+        public FileDeleteOperation(IServiceProvider serviceProvider, FileDeleteOperationData<T> fileOperationData)
             : base(serviceProvider, fileOperationData)
         {
             _ignoreException = fileOperationData.IgnoreException;
@@ -99,7 +99,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
             DeleteFolders(Folders, scope);
         }
 
-        private void DeleteFolders(IEnumerable<object> folderIds, IServiceScope scope)
+        private void DeleteFolders(IEnumerable<T> folderIds, IServiceScope scope)
         {
             var fileMarker = scope.ServiceProvider.GetService<FileMarker>();
             var filesMessageService = scope.ServiceProvider.GetService<FilesMessageService>();
@@ -109,7 +109,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
                 CancellationToken.ThrowIfCancellationRequested();
 
                 var folder = FolderDao.GetFolder(folderId);
-                object canCalculate = null;
+                T canCalculate = default;
                 if (folder == null)
                 {
                     Error = FilesCommonResource.ErrorMassage_FolderNotFound;
@@ -120,13 +120,13 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
                 }
                 else if (!_ignoreException && !FilesSecurity.CanDelete(folder))
                 {
-                    canCalculate = FolderDao.CanCalculateSubitems(folderId) ? null : folderId;
+                    canCalculate = FolderDao.CanCalculateSubitems(folderId) ? default : folderId;
 
                     Error = FilesCommonResource.ErrorMassage_SecurityException_DeleteFolder;
                 }
                 else
                 {
-                    canCalculate = FolderDao.CanCalculateSubitems(folderId) ? null : folderId;
+                    canCalculate = FolderDao.CanCalculateSubitems(folderId) ? default : folderId;
 
                     fileMarker.RemoveMarkAsNewForAll(folder);
                     if (folder.ProviderEntry && folder.ID.Equals(folder.RootFolderId))
@@ -142,7 +142,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
                     else
                     {
                         var immediately = _immediately || !FolderDao.UseTrashForRemove(folder);
-                        if (immediately && FolderDao.UseRecursiveOperation(folder.ID, null))
+                        if (immediately && FolderDao.UseRecursiveOperation(folder.ID, default))
                         {
                             DeleteFiles(FileDao.GetFiles(folder.ID), scope);
                             DeleteFolders(FolderDao.GetFolders(folder.ID).Select(f => f.ID).ToList(), scope);
@@ -184,7 +184,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
             }
         }
 
-        private void DeleteFiles(IEnumerable<object> fileIds, IServiceScope scope)
+        private void DeleteFiles(IEnumerable<T> fileIds, IServiceScope scope)
         {
             var fileMarker = scope.ServiceProvider.GetService<FileMarker>();
             var filesMessageService = scope.ServiceProvider.GetService<FilesMessageService>();
@@ -225,7 +225,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
                     }
                     ProcessedFile(fileId);
                 }
-                ProgressStep(fileId: FolderDao.CanCalculateSubitems(fileId) ? null : fileId);
+                ProgressStep(fileId: FolderDao.CanCalculateSubitems(fileId) ? default : fileId);
             }
         }
 

products/ASC.Files/Server/Services/WCFService/FileOperations/FileDownloadOperation.cs

@@ -47,16 +47,14 @@ using Ionic.Zip;
 
 using Microsoft.Extensions.DependencyInjection;
 
-using File = ASC.Files.Core.File;
-
 namespace ASC.Web.Files.Services.WCFService.FileOperations
 {
-    internal class FileDownloadOperationData : FileOperationData
+    internal class FileDownloadOperationData<T> : FileOperationData<T>
     {
-        public Dictionary<object, string> FilesDownload { get; }
+        public Dictionary<T, string> FilesDownload { get; }
         public Dictionary<string, string> Headers { get; }
 
-        public FileDownloadOperationData(Dictionary<object, string> folders, Dictionary<object, string> files, Tenant tenant, Dictionary<string, string> headers, bool holdResult = true)
+        public FileDownloadOperationData(Dictionary<T, string> folders, Dictionary<T, string> files, Tenant tenant, Dictionary<string, string> headers, bool holdResult = true)
             : base(folders.Select(f => f.Key).ToList(), files.Select(f => f.Key).ToList(), tenant, holdResult)
         {
             FilesDownload = files;
@@ -64,9 +62,9 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
         }
     }
 
-    class FileDownloadOperation : FileOperation<FileDownloadOperationData>
+    class FileDownloadOperation<T> : FileOperation<FileDownloadOperationData<T>, T>
     {
-        private readonly Dictionary<object, string> files;
+        private readonly Dictionary<T, string> files;
         private readonly Dictionary<string, string> headers;
 
         public override FileOperationType OperationType
@@ -75,7 +73,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
         }
 
 
-        public FileDownloadOperation(IServiceProvider serviceProvider, FileDownloadOperationData fileDownloadOperationData)
+        public FileDownloadOperation(IServiceProvider serviceProvider, FileDownloadOperationData<T> fileDownloadOperationData)
             : base(serviceProvider, fileDownloadOperationData)
         {
             files = fileDownloadOperationData.FilesDownload;
@@ -114,16 +112,16 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
             }
         }
 
-        private ItemNameValueCollection ExecPathFromFile(IServiceScope scope, File file, string path)
+        private ItemNameValueCollection<T> ExecPathFromFile(IServiceScope scope, File<T> file, string path)
         {
             var fileMarker = scope.ServiceProvider.GetService<FileMarker>();
             fileMarker.RemoveMarkAsNew(file);
 
             var title = file.Title;
 
-            if (files.ContainsKey(file.ID.ToString()))
+            if (files.ContainsKey(file.ID))
             {
-                var convertToExt = files[file.ID.ToString()];
+                var convertToExt = files[file.ID];
 
                 if (!string.IsNullOrEmpty(convertToExt))
                 {
@@ -131,16 +129,16 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
                 }
             }
 
-            var entriesPathId = new ItemNameValueCollection();
-            entriesPathId.Add(path + title, file.ID.ToString());
+            var entriesPathId = new ItemNameValueCollection<T>();
+            entriesPathId.Add(path + title, file.ID);
 
             return entriesPathId;
         }
 
-        private ItemNameValueCollection GetEntriesPathId(IServiceScope scope)
+        private ItemNameValueCollection<T> GetEntriesPathId(IServiceScope scope)
         {
             var fileMarker = scope.ServiceProvider.GetService<FileMarker>();
-            var entriesPathId = new ItemNameValueCollection();
+            var entriesPathId = new ItemNameValueCollection<T>();
             if (0 < Files.Count)
             {
                 var files = FileDao.GetFiles(Files.ToArray());
@@ -158,13 +156,13 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
             return entriesPathId;
         }
 
-        private ItemNameValueCollection GetFilesInFolders(IServiceScope scope, IEnumerable<object> folderIds, string path)
+        private ItemNameValueCollection<T> GetFilesInFolders(IServiceScope scope, IEnumerable<T> folderIds, string path)
         {
             var fileMarker = scope.ServiceProvider.GetService<FileMarker>();
 
             CancellationToken.ThrowIfCancellationRequested();
 
-            var entriesPathId = new ItemNameValueCollection();
+            var entriesPathId = new ItemNameValueCollection<T>();
             foreach (var folderId in folderIds)
             {
                 CancellationToken.ThrowIfCancellationRequested();
@@ -183,7 +181,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
                 nestedFolders = FilesSecurity.FilterRead(nestedFolders).ToList();
                 if (files.Count == 0 && nestedFolders.Count == 0)
                 {
-                    entriesPathId.Add(folderPath, string.Empty);
+                    entriesPathId.Add(folderPath, default(T));
                 }
 
                 var filesInFolder = GetFilesInFolders(scope, nestedFolders.ConvertAll(f => f.ID), folderPath);
@@ -192,7 +190,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
             return entriesPathId;
         }
 
-        private Stream CompressToZip(IServiceScope scope, ItemNameValueCollection entriesPathId)
+        private Stream CompressToZip(IServiceScope scope, ItemNameValueCollection<T> entriesPathId)
         {
             var setupInfo = scope.ServiceProvider.GetService<SetupInfo>();
             var fileConverter = scope.ServiceProvider.GetService<FileConverter>();
@@ -219,10 +217,10 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
 
                         var newtitle = path;
 
-                        File file = null;
+                        File<T> file = null;
                         var convertToExt = string.Empty;
 
-                        if (!string.IsNullOrEmpty(entryId))
+                        if (!entryId.Equals(default(T)))
                         {
                             FileDao.InvalidateCache(entryId);
                             file = FileDao.GetFile(entryId);
@@ -239,9 +237,9 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
                                 continue;
                             }
 
-                            if (files.ContainsKey(file.ID.ToString()))
+                            if (files.ContainsKey(file.ID))
                             {
-                                convertToExt = files[file.ID.ToString()];
+                                convertToExt = files[file.ID];
                                 if (!string.IsNullOrEmpty(convertToExt))
                                 {
                                     newtitle = FileUtility.ReplaceFileExtension(path, convertToExt);
@@ -253,7 +251,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
                         {
                             var suffix = " (" + counter + ")";
 
-                            if (!string.IsNullOrEmpty(entryId))
+                            if (!entryId.Equals(default(T)))
                             {
                                 newtitle = 0 < newtitle.IndexOf('.') ? newtitle.Insert(newtitle.LastIndexOf('.'), suffix) : newtitle + suffix;
                             }
@@ -265,7 +263,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
 
                         zip.PutNextEntry(newtitle);
 
-                        if (!string.IsNullOrEmpty(entryId) && file != null)
+                        if (!entryId.Equals(default(T)) && file != null)
                         {
                             try
                             {
@@ -307,7 +305,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
             return stream;
         }
 
-        private void ReplaceLongPath(ItemNameValueCollection entriesPathId)
+        private void ReplaceLongPath(ItemNameValueCollection<T> entriesPathId)
         {
             foreach (var path in new List<string>(entriesPathId.AllKeys))
             {
@@ -324,9 +322,9 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
         }
 
 
-        class ItemNameValueCollection
+        class ItemNameValueCollection<T>
         {
-            private readonly Dictionary<string, List<string>> dic = new Dictionary<string, List<string>>();
+            private readonly Dictionary<string, List<T>> dic = new Dictionary<string, List<T>>();
 
 
             public IEnumerable<string> AllKeys
@@ -334,7 +332,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
                 get { return dic.Keys; }
             }
 
-            public IEnumerable<string> this[string name]
+            public IEnumerable<T> this[string name]
             {
                 get { return dic[name].ToArray(); }
             }
@@ -344,16 +342,16 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
                 get { return dic.Count; }
             }
 
-            public void Add(string name, string value)
+            public void Add(string name, T value)
             {
                 if (!dic.ContainsKey(name))
                 {
-                    dic.Add(name, new List<string>());
+                    dic.Add(name, new List<T>());
                 }
                 dic[name].Add(value);
             }
 
-            public void Add(ItemNameValueCollection collection)
+            public void Add(ItemNameValueCollection<T> collection)
             {
                 foreach (var key in collection.AllKeys)
                 {
@@ -364,11 +362,11 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
                 }
             }
 
-            public void Add(string name, IEnumerable<string> values)
+            public void Add(string name, IEnumerable<T> values)
             {
                 if (!dic.ContainsKey(name))
                 {
-                    dic.Add(name, new List<string>());
+                    dic.Add(name, new List<T>());
                 }
                 dic[name].AddRange(values);
             }

products/ASC.Files/Server/Services/WCFService/FileOperations/FileMarkAsReadOperation.cs

@@ -38,14 +38,14 @@ using Microsoft.Extensions.DependencyInjection;
 
 namespace ASC.Web.Files.Services.WCFService.FileOperations
 {
-    class FileMarkAsReadOperationData : FileOperationData
+    class FileMarkAsReadOperationData<T> : FileOperationData<T>
     {
-        public FileMarkAsReadOperationData(List<object> folders, List<object> files, Tenant tenant, bool holdResult = true) : base(folders, files, tenant, holdResult)
+        public FileMarkAsReadOperationData(List<T> folders, List<T> files, Tenant tenant, bool holdResult = true) : base(folders, files, tenant, holdResult)
         {
         }
     }
 
-    class FileMarkAsReadOperation : FileOperation<FileMarkAsReadOperationData>
+    class FileMarkAsReadOperation<T> : FileOperation<FileMarkAsReadOperationData<T>, T>
     {
         public override FileOperationType OperationType
         {
@@ -53,7 +53,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
         }
 
 
-        public FileMarkAsReadOperation(IServiceProvider serviceProvider, FileMarkAsReadOperationData fileOperationData)
+        public FileMarkAsReadOperation(IServiceProvider serviceProvider, FileMarkAsReadOperationData<T> fileOperationData)
             : base(serviceProvider, fileOperationData)
         {
         }
@@ -84,11 +84,11 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
 
                 if (x.FileEntryType == FileEntryType.File)
                 {
-                    ProcessedFile(x.ID.ToString());
+                    ProcessedFile(((File<T>)x).ID);
                 }
                 else
                 {
-                    ProcessedFolder(x.ID.ToString());
+                    ProcessedFolder(((Folder<T>)x).ID);
                 }
                 ProgressStep();
             });

products/ASC.Files/Server/Services/WCFService/FileOperations/FileMoveCopyOperation.cs

@@ -25,7 +25,6 @@
 
 
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -42,14 +41,14 @@ using Microsoft.Extensions.DependencyInjection;
 
 namespace ASC.Web.Files.Services.WCFService.FileOperations
 {
-    internal class FileMoveCopyOperationData : FileOperationData
+    internal class FileMoveCopyOperationData<T> : FileOperationData<T>
     {
-        public string ToFolderId { get; }
+        public T ToFolderId { get; }
         public bool Copy { get; }
         public FileConflictResolveType ResolveType { get; }
         public Dictionary<string, string> Headers { get; }
 
-        public FileMoveCopyOperationData(List<object> folders, List<object> files, Tenant tenant, string toFolderId, bool copy, FileConflictResolveType resolveType, bool holdResult = true, Dictionary<string, string> headers = null)
+        public FileMoveCopyOperationData(List<T> folders, List<T> files, Tenant tenant, T toFolderId, bool copy, FileConflictResolveType resolveType, bool holdResult = true, Dictionary<string, string> headers = null)
             : base(folders, files, tenant, holdResult)
         {
             ToFolderId = toFolderId;
@@ -59,9 +58,9 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
         }
     }
 
-    class FileMoveCopyOperation : FileOperation<FileMoveCopyOperationData>
+    class FileMoveCopyOperation<T> : FileOperation<FileMoveCopyOperationData<T>, T>
     {
-        private readonly string _toFolderId;
+        private readonly T _toFolderId;
         private readonly bool _copy;
         private readonly FileConflictResolveType _resolveType;
         private readonly List<FileEntry> _needToMark = new List<FileEntry>();
@@ -73,7 +72,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
             get { return _copy ? FileOperationType.Copy : FileOperationType.Move; }
         }
 
-        public FileMoveCopyOperation(IServiceProvider serviceProvider, FileMoveCopyOperationData data)
+        public FileMoveCopyOperation(IServiceProvider serviceProvider, FileMoveCopyOperationData<T> data)
             : base(serviceProvider, data)
         {
             _toFolderId = data.ToFolderId;
@@ -94,7 +93,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
             if (toFolder == null) return;
             if (!FilesSecurity.CanCreate(toFolder)) throw new System.Security.SecurityException(FilesCommonResource.ErrorMassage_SecurityException_Create);
 
-            if (FolderDao.GetParentFolders(toFolder.ID).Any(parent => Folders.Contains(parent.ID.ToString())))
+            if (FolderDao.GetParentFolders(toFolder.ID).Any(parent => Folders.Contains(parent.ID)))
             {
                 Error = FilesCommonResource.ErrorMassage_FolderCopyError;
                 return;
@@ -115,7 +114,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
             _needToMark.Distinct().ToList().ForEach(x => fileMarker.MarkAsNew(x));
         }
 
-        private void MoveOrCopyFolders(IServiceScope scope, ICollection folderIds, Folder toFolder, bool copy)
+        private void MoveOrCopyFolders(IServiceScope scope, List<T> folderIds, Folder<T> toFolder, bool copy)
         {
             if (folderIds.Count == 0) return;
 
@@ -137,13 +136,13 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
                 {
                     Error = FilesCommonResource.ErrorMassage_SecurityException_ReadFolder;
                 }
-                else if (!Equals((folder.ParentFolderID ?? string.Empty).ToString(), toFolderId.ToString()) || _resolveType == FileConflictResolveType.Duplicate)
+                else if (!Equals((folder.ParentFolderID ?? default).ToString(), toFolderId.ToString()) || _resolveType == FileConflictResolveType.Duplicate)
                 {
                     try
                     {
                         //if destination folder contains folder with same name then merge folders
                         var conflictFolder = FolderDao.GetFolder(folder.Title, toFolderId);
-                        Folder newFolder;
+                        Folder<T> newFolder;
 
                         if (copy || conflictFolder != null)
                         {
@@ -193,7 +192,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
                             {
                                 if (conflictFolder != null)
                                 {
-                                    object newFolderId;
+                                    T newFolderId;
                                     if (copy)
                                     {
                                         newFolder = FolderDao.CopyFolder(folder.ID, toFolderId, CancellationToken);
@@ -270,11 +269,11 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
                         Logger.Error(Error, ex);
                     }
                 }
-                ProgressStep(FolderDao.CanCalculateSubitems(folderId) ? null : folderId);
+                ProgressStep(FolderDao.CanCalculateSubitems(folderId) ? default : folderId);
             }
         }
 
-        private void MoveOrCopyFiles(IServiceScope scope, ICollection fileIds, Folder toFolder, bool copy)
+        private void MoveOrCopyFiles(IServiceScope scope, List<T> fileIds, Folder<T> toFolder, bool copy)
         {
             if (fileIds.Count == 0) return;
 
@@ -313,7 +312,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
                                            : FileDao.GetFile(toFolderId, file.Title);
                         if (conflict == null)
                         {
-                            File newFile = null;
+                            File<T> newFile = null;
                             if (copy)
                             {
                                 try
@@ -451,7 +450,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
                         Logger.Error(Error, ex);
                     }
                 }
-                ProgressStep(fileId: FolderDao.CanCalculateSubitems(fileId) ? null : fileId);
+                ProgressStep(fileId: FolderDao.CanCalculateSubitems(fileId) ? default : fileId);
             }
         }
 

products/ASC.Files/Server/Services/WCFService/FileOperations/FileOperation.cs

@@ -48,20 +48,20 @@ using Microsoft.Extensions.Options;
 
 namespace ASC.Web.Files.Services.WCFService.FileOperations
 {
-    abstract class FileOperationData
+    abstract class FileOperationData<T>
     {
-        public List<object> Folders { get; private set; }
+        public List<T> Folders { get; private set; }
 
-        public List<object> Files { get; private set; }
+        public List<T> Files { get; private set; }
 
         public Tenant Tenant { get; }
 
         public bool HoldResult { get; private set; }
 
-        protected FileOperationData(List<object> folders, List<object> files, Tenant tenant, bool holdResult = true)
+        protected FileOperationData(List<T> folders, List<T> files, Tenant tenant, bool holdResult = true)
         {
-            Folders = folders ?? new List<object>();
-            Files = files ?? new List<object>();
+            Folders = folders ?? new List<T>();
+            Files = files ?? new List<T>();
             Tenant = tenant;
             HoldResult = holdResult;
         }
@@ -81,7 +81,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
         public const string HOLD = "Hold";
     }
 
-    abstract class FileOperation<T> where T : FileOperationData
+    abstract class FileOperation<T, TId> where T : FileOperationData<TId>
     {
         private readonly IPrincipal principal;
         private readonly string culture;
@@ -100,9 +100,9 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
 
         protected FileSecurity FilesSecurity { get; private set; }
 
-        protected IFolderDao FolderDao { get; private set; }
+        protected IFolderDao<TId> FolderDao { get; private set; }
 
-        protected IFileDao FileDao { get; private set; }
+        protected IFileDao<TId> FileDao { get; private set; }
 
         protected ITagDao TagDao { get; private set; }
 
@@ -112,9 +112,9 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
 
         protected CancellationToken CancellationToken { get; private set; }
 
-        protected List<object> Folders { get; private set; }
+        protected List<TId> Folders { get; private set; }
 
-        protected List<object> Files { get; private set; }
+        protected List<TId> Files { get; private set; }
 
         protected bool HoldResult { get; private set; }
 
@@ -152,8 +152,8 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
                 Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo(culture);
                 Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo(culture);
 
-                FolderDao = daoFactory.FolderDao;
-                FileDao = daoFactory.FileDao;
+                FolderDao = daoFactory.GetFolderDao<TId>();
+                FileDao = daoFactory.GetFileDao<TId>();
                 TagDao = daoFactory.TagDao;
                 ProviderDao = daoFactory.ProviderDao;
                 FilesSecurity = fileSecurity;
@@ -219,7 +219,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
             return count;
         }
 
-        protected void ProgressStep(object folderId = null, object fileId = null)
+        protected void ProgressStep(TId folderId = default, TId fileId = default)
         {
             if (folderId == null && fileId == null
                 || folderId != null && Folders.Contains(folderId)
@@ -230,7 +230,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
             }
         }
 
-        protected bool ProcessedFolder(object folderId)
+        protected bool ProcessedFolder(TId folderId)
         {
             successProcessed++;
             if (Folders.Contains(folderId))
@@ -241,7 +241,7 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
             return false;
         }
 
-        protected bool ProcessedFile(object fileId)
+        protected bool ProcessedFile(TId fileId)
         {
             successProcessed++;
             if (Files.Contains(fileId))

products/ASC.Files/Server/Services/WCFService/FileOperations/FileOperationsManager.cs

@@ -98,13 +98,13 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
         }
 
 
-        public ItemList<FileOperationResult> MarkAsRead(AuthContext authContext, TenantManager tenantManager, List<object> folderIds, List<object> fileIds)
+        public ItemList<FileOperationResult> MarkAsRead<T>(AuthContext authContext, TenantManager tenantManager, List<T> folderIds, List<T> fileIds)
         {
-            var op = new FileMarkAsReadOperation(ServiceProvider, new FileMarkAsReadOperationData(folderIds, fileIds, tenantManager.GetCurrentTenant()));
+            var op = new FileMarkAsReadOperation<T>(ServiceProvider, new FileMarkAsReadOperationData<T>(folderIds, fileIds, tenantManager.GetCurrentTenant()));
             return QueueTask(authContext, op);
         }
 
-        public ItemList<FileOperationResult> Download(AuthContext authContext, TenantManager tenantManager, Dictionary<object, string> folders, Dictionary<object, string> files, Dictionary<string, string> headers)
+        public ItemList<FileOperationResult> Download<T>(AuthContext authContext, TenantManager tenantManager, Dictionary<T, string> folders, Dictionary<T, string> files, Dictionary<string, string> headers)
         {
             var operations = tasks.GetTasks()
                 .Where(t => t.GetProperty<Guid>(FileOperation.OWNER) == authContext.CurrentAccount.ID)
@@ -115,24 +115,24 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
                 throw new InvalidOperationException(FilesCommonResource.ErrorMassage_ManyDownloads);
             }
 
-            var op = new FileDownloadOperation(ServiceProvider, new FileDownloadOperationData(folders, files, tenantManager.GetCurrentTenant(), headers));
+            var op = new FileDownloadOperation<T>(ServiceProvider, new FileDownloadOperationData<T>(folders, files, tenantManager.GetCurrentTenant(), headers));
             return QueueTask(authContext, op);
         }
 
-        public ItemList<FileOperationResult> MoveOrCopy(AuthContext authContext, TenantManager tenantManager, List<object> folders, List<object> files, string destFolderId, bool copy, FileConflictResolveType resolveType, bool holdResult, Dictionary<string, string> headers)
+        public ItemList<FileOperationResult> MoveOrCopy<T>(AuthContext authContext, TenantManager tenantManager, List<T> folders, List<T> files, T destFolderId, bool copy, FileConflictResolveType resolveType, bool holdResult, Dictionary<string, string> headers)
         {
-            var op = new FileMoveCopyOperation(ServiceProvider, new FileMoveCopyOperationData(folders, files, tenantManager.GetCurrentTenant(), destFolderId, copy, resolveType, holdResult, headers));
+            var op = new FileMoveCopyOperation<T>(ServiceProvider, new FileMoveCopyOperationData<T>(folders, files, tenantManager.GetCurrentTenant(), destFolderId, copy, resolveType, holdResult, headers));
             return QueueTask(authContext, op);
         }
 
-        public ItemList<FileOperationResult> Delete(AuthContext authContext, TenantManager tenantManager, List<object> folders, List<object> files, bool ignoreException, bool holdResult, bool immediately, Dictionary<string, string> headers)
+        public ItemList<FileOperationResult> Delete<T>(AuthContext authContext, TenantManager tenantManager, List<T> folders, List<T> files, bool ignoreException, bool holdResult, bool immediately, Dictionary<string, string> headers)
         {
-            var op = new FileDeleteOperation(ServiceProvider, new FileDeleteOperationData(folders, files, tenantManager.GetCurrentTenant(), holdResult, ignoreException, immediately, headers));
+            var op = new FileDeleteOperation<T>(ServiceProvider, new FileDeleteOperationData<T>(folders, files, tenantManager.GetCurrentTenant(), holdResult, ignoreException, immediately, headers));
             return QueueTask(authContext, op);
         }
 
 
-        private ItemList<FileOperationResult> QueueTask<T>(AuthContext authContext, FileOperation<T> op) where T : FileOperationData
+        private ItemList<FileOperationResult> QueueTask<T, TId>(AuthContext authContext, FileOperation<T, TId> op) where T : FileOperationData<TId>
         {
             tasks.QueueTask(op.RunJob, op.GetDistributedTask());
             return GetOperationResults(authContext);
@@ -157,15 +157,15 @@ namespace ASC.Web.Files.Services.WCFService.FileOperations
 
         public ItemList<FileOperationResult> GetOperationResults() => FileOperationsManager.GetOperationResults(AuthContext);
         public ItemList<FileOperationResult> CancelOperations() => FileOperationsManager.CancelOperations(AuthContext);
-        public ItemList<FileOperationResult> MarkAsRead(List<object> folderIds, List<object> fileIds)
+        public ItemList<FileOperationResult> MarkAsRead<T>(List<T> folderIds, List<T> fileIds)
             => FileOperationsManager.MarkAsRead(AuthContext, TenantManager, folderIds, fileIds);
-        public ItemList<FileOperationResult> Download(Dictionary<object, string> folders, Dictionary<object, string> files, Dictionary<string, string> headers)
+        public ItemList<FileOperationResult> Download<T>(Dictionary<T, string> folders, Dictionary<T, string> files, Dictionary<string, string> headers)
             => FileOperationsManager.Download(AuthContext, TenantManager, folders, files, headers);
 
-        public ItemList<FileOperationResult> MoveOrCopy(List<object> folders, List<object> files, string destFolderId, bool copy, FileConflictResolveType resolveType, bool holdResult, Dictionary<string, string> headers)
+        public ItemList<FileOperationResult> MoveOrCopy<T>(List<T> folders, List<T> files, T destFolderId, bool copy, FileConflictResolveType resolveType, bool holdResult, Dictionary<string, string> headers)
             => FileOperationsManager.MoveOrCopy(AuthContext, TenantManager, folders, files, destFolderId, copy, resolveType, holdResult, headers);
 
-        public ItemList<FileOperationResult> Delete(List<object> folders, List<object> files, bool ignoreException, bool holdResult, bool immediately, Dictionary<string, string> headers)
+        public ItemList<FileOperationResult> Delete<T>(List<T> folders, List<T> files, bool ignoreException, bool holdResult, bool immediately, Dictionary<string, string> headers)
             => FileOperationsManager.Delete(AuthContext, TenantManager, folders, files, ignoreException, holdResult, immediately, headers);
     }
 

products/ASC.Files/Server/Services/WCFService/IFileStorageService.cs

@@ -73,7 +73,7 @@ namespace ASC.Web.Files.Services.WCFService
 
         File GetFile(string fileId, int version);
 
-        File CreateNewFile(FileModel fileWrapper);
+        File<T> CreateNewFile<T>(FileModel<T> fileWrapper);
 
         File FileRename(string fileId, string title);
 

products/ASC.Files/Server/Utils/ChunkedUploadSessionHolder.cs

@@ -36,8 +36,6 @@ using ASC.Web.Studio.Core;
 
 using Microsoft.Extensions.Options;
 
-using File = ASC.Files.Core.File;
-
 namespace ASC.Web.Files.Utils
 {
     public class ChunkedUploadSessionHolder
@@ -65,49 +63,49 @@ namespace ASC.Web.Files.Utils
             }
         }
 
-        public void StoreSession(ChunkedUploadSession s)
+        public void StoreSession<T>(ChunkedUploadSession<T> s)
         {
             CommonSessionHolder(false).Store(s);
         }
 
-        public void RemoveSession(ChunkedUploadSession s)
+        public void RemoveSession<T>(ChunkedUploadSession<T> s)
         {
             CommonSessionHolder(false).Remove(s);
         }
 
-        public ChunkedUploadSession GetSession(string sessionId)
+        public ChunkedUploadSession<T> GetSession<T>(string sessionId)
         {
-            return (ChunkedUploadSession)CommonSessionHolder(false).Get(sessionId);
+            return (ChunkedUploadSession<T>)CommonSessionHolder(false).Get(sessionId);
         }
 
-        public ChunkedUploadSession CreateUploadSession(File file, long contentLength)
+        public ChunkedUploadSession<T> CreateUploadSession<T>(File<T> file, long contentLength)
         {
-            var result = new ChunkedUploadSession(file, contentLength);
+            var result = new ChunkedUploadSession<T>(file, contentLength);
             CommonSessionHolder().Init(result);
             return result;
         }
 
-        public void UploadChunk(ChunkedUploadSession uploadSession, Stream stream, long length)
+        public void UploadChunk<T>(ChunkedUploadSession<T> uploadSession, Stream stream, long length)
         {
             CommonSessionHolder().UploadChunk(uploadSession, stream, length);
         }
 
-        public void FinalizeUploadSession(ChunkedUploadSession uploadSession)
+        public void FinalizeUploadSession<T>(ChunkedUploadSession<T> uploadSession)
         {
             CommonSessionHolder().Finalize(uploadSession);
         }
 
-        public void Move(ChunkedUploadSession chunkedUploadSession, string newPath)
+        public void Move<T>(ChunkedUploadSession<T> chunkedUploadSession, string newPath)
         {
             CommonSessionHolder().Move(chunkedUploadSession, newPath);
         }
 
-        public void AbortUploadSession(ChunkedUploadSession uploadSession)
+        public void AbortUploadSession<T>(ChunkedUploadSession<T> uploadSession)
         {
             CommonSessionHolder().Abort(uploadSession);
         }
 
-        public Stream UploadSingleChunk(ChunkedUploadSession uploadSession, Stream stream, long chunkLength)
+        public Stream UploadSingleChunk<T>(ChunkedUploadSession<T> uploadSession, Stream stream, long chunkLength)
         {
             return CommonSessionHolder().UploadSingleChunk(uploadSession, stream, chunkLength);
         }

products/ASC.Files/Server/Utils/EntryManager.cs

@@ -805,6 +805,146 @@ namespace ASC.Web.Files.Utils
             return file;
         }
 
+        public File<T> SaveEditing<T>(T fileId, string fileExtension, string downloadUri, Stream stream, string doc, string comment = null, bool checkRight = true, bool encrypted = false, ForcesaveType? forcesave = null)
+        {
+            var newExtension = string.IsNullOrEmpty(fileExtension)
+                              ? FileUtility.GetFileExtension(downloadUri)
+                              : fileExtension;
+
+            var app = ThirdPartySelector.GetAppByFileId(fileId.ToString());
+            if (app != null)
+            {
+                app.SaveFile(fileId.ToString(), newExtension, downloadUri, stream);
+                return null;
+            }
+
+            var fileDao = DaoFactory.GetFileDao<T>();
+            var editLink = FileShareLink.Check<T>(doc, false, fileDao, out var file);
+            if (file == null)
+            {
+                file = fileDao.GetFile(fileId);
+            }
+
+            if (file == null) throw new FileNotFoundException(FilesCommonResource.ErrorMassage_FileNotFound);
+            var fileSecurity = FileSecurity;
+            if (checkRight && !editLink && (!(fileSecurity.CanEdit(file) || fileSecurity.CanReview(file)) || UserManager.GetUsers(AuthContext.CurrentAccount.ID).IsVisitor(UserManager))) throw new SecurityException(FilesCommonResource.ErrorMassage_SecurityException_EditFile);
+            if (checkRight && FileLockedForMe(file.ID)) throw new Exception(FilesCommonResource.ErrorMassage_LockedFile);
+            if (checkRight && FileTracker.IsEditing(file.ID)) throw new Exception(FilesCommonResource.ErrorMassage_SecurityException_UpdateEditingFile);
+            if (file.RootFolderType == FolderType.TRASH) throw new Exception(FilesCommonResource.ErrorMassage_ViewTrashItem);
+
+            var currentExt = file.ConvertedExtension;
+            if (string.IsNullOrEmpty(newExtension)) newExtension = FileUtility.GetInternalExtension(file.Title);
+
+            var replaceVersion = false;
+            if (file.Forcesave != ForcesaveType.None)
+            {
+                if (file.Forcesave == ForcesaveType.User && FilesSettingsHelper.StoreForcesave)
+                {
+                    file.Version++;
+                }
+                else
+                {
+                    replaceVersion = true;
+                }
+            }
+            else
+            {
+                if (file.Version != 1)
+                {
+                    file.VersionGroup++;
+                }
+                else
+                {
+                    var storeTemplate = GlobalStore.GetStoreTemplate();
+
+                    var path = FileConstant.NewDocPath + Thread.CurrentThread.CurrentCulture + "/";
+                    if (!storeTemplate.IsDirectory(path))
+                    {
+                        path = FileConstant.NewDocPath + "default/";
+                    }
+                    path += "new" + FileUtility.GetInternalExtension(file.Title);
+
+                    //todo: think about the criteria for saving after creation
+                    if (file.ContentLength != storeTemplate.GetFileSize("", path))
+                    {
+                        file.VersionGroup++;
+                    }
+                }
+                file.Version++;
+            }
+            file.Forcesave = forcesave ?? ForcesaveType.None;
+
+            if (string.IsNullOrEmpty(comment))
+                comment = FilesCommonResource.CommentEdit;
+
+            file.Encrypted = encrypted;
+
+            file.ConvertedType = FileUtility.GetFileExtension(file.Title) != newExtension ? newExtension : null;
+
+            if (file.ProviderEntry && !newExtension.Equals(currentExt))
+            {
+                if (FileUtility.ExtsConvertible.Keys.Contains(newExtension)
+                    && FileUtility.ExtsConvertible[newExtension].Contains(currentExt))
+                {
+                    if (stream != null)
+                    {
+                        downloadUri = PathProvider.GetTempUrl(stream, newExtension);
+                        downloadUri = DocumentServiceConnector.ReplaceCommunityAdress(downloadUri);
+                    }
+
+                    var key = DocumentServiceConnector.GenerateRevisionId(downloadUri);
+                    DocumentServiceConnector.GetConvertedUri(downloadUri, newExtension, currentExt, key, null, false, out downloadUri);
+
+                    stream = null;
+                }
+                else
+                {
+                    file.ID = default;
+                    file.Title = FileUtility.ReplaceFileExtension(file.Title, newExtension);
+                }
+
+                file.ConvertedType = null;
+            }
+
+            using (var tmpStream = new MemoryStream())
+            {
+                if (stream != null)
+                {
+                    stream.CopyTo(tmpStream);
+                }
+                else
+                {
+                    // hack. http://ubuntuforums.org/showthread.php?t=1841740
+                    if (WorkContext.IsMono)
+                    {
+                        ServicePointManager.ServerCertificateValidationCallback += (s, ce, ca, p) => true;
+                    }
+
+                    var req = (HttpWebRequest)WebRequest.Create(downloadUri);
+                    using (var editedFileStream = new ResponseStream(req.GetResponse()))
+                    {
+                        editedFileStream.CopyTo(tmpStream);
+                    }
+                }
+                tmpStream.Position = 0;
+
+                file.ContentLength = tmpStream.Length;
+                file.Comment = string.IsNullOrEmpty(comment) ? null : comment;
+                if (replaceVersion)
+                {
+                    file = fileDao.ReplaceFileVersion(file, tmpStream);
+                }
+                else
+                {
+                    file = fileDao.SaveFile(file, tmpStream);
+                }
+            }
+
+            FileMarker.MarkAsNew(file);
+            FileMarker.RemoveMarkAsNew(file);
+            return file;
+        }
+
         public void TrackEditing(string fileId, Guid tabId, Guid userId, string doc, bool editingAlone = false)
         {
             bool checkRight;
@@ -908,6 +1048,80 @@ namespace ASC.Web.Files.Utils
             }
         }
 
+        public File<T> UpdateToVersionFile<T>(T fileId, int version, string doc = null, bool checkRight = true)
+        {
+            var fileDao = DaoFactory.GetFileDao<T>();
+            if (version < 1) throw new ArgumentNullException("version");
+
+            var editLink = FileShareLink.Check(doc, false, fileDao, out var fromFile);
+
+            if (fromFile == null)
+                fromFile = fileDao.GetFile(fileId);
+
+            if (fromFile == null) throw new FileNotFoundException(FilesCommonResource.ErrorMassage_FileNotFound);
+
+            if (fromFile.Version != version)
+                fromFile = fileDao.GetFile(fromFile.ID, Math.Min(fromFile.Version, version));
+
+            if (fromFile == null) throw new FileNotFoundException(FilesCommonResource.ErrorMassage_FileNotFound);
+            if (checkRight && !editLink && (!FileSecurity.CanEdit(fromFile) || UserManager.GetUsers(AuthContext.CurrentAccount.ID).IsVisitor(UserManager))) throw new SecurityException(FilesCommonResource.ErrorMassage_SecurityException_EditFile);
+            if (FileLockedForMe(fromFile.ID)) throw new Exception(FilesCommonResource.ErrorMassage_LockedFile);
+            if (checkRight && FileTracker.IsEditing(fromFile.ID)) throw new Exception(FilesCommonResource.ErrorMassage_SecurityException_UpdateEditingFile);
+            if (fromFile.RootFolderType == FolderType.TRASH) throw new Exception(FilesCommonResource.ErrorMassage_ViewTrashItem);
+            if (fromFile.ProviderEntry) throw new Exception(FilesCommonResource.ErrorMassage_BadRequest);
+
+            var exists = cache.Get<string>(UPDATE_LIST + fileId.ToString()) != null;
+            if (exists)
+            {
+                throw new Exception(FilesCommonResource.ErrorMassage_UpdateEditingFile);
+            }
+            else
+            {
+                cache.Insert(UPDATE_LIST + fileId.ToString(), fileId.ToString(), TimeSpan.FromMinutes(2));
+            }
+
+            try
+            {
+                var currFile = fileDao.GetFile(fileId);
+                var newFile = ServiceProvider.GetService<File<T>>();
+
+                newFile.ID = fromFile.ID;
+                newFile.Version = currFile.Version + 1;
+                newFile.VersionGroup = currFile.VersionGroup;
+                newFile.Title = FileUtility.ReplaceFileExtension(currFile.Title, FileUtility.GetFileExtension(fromFile.Title));
+                newFile.FileStatus = currFile.FileStatus;
+                newFile.FolderID = currFile.FolderID;
+                newFile.CreateBy = currFile.CreateBy;
+                newFile.CreateOn = currFile.CreateOn;
+                newFile.ModifiedBy = fromFile.ModifiedBy;
+                newFile.ModifiedOn = fromFile.ModifiedOn;
+                newFile.ConvertedType = fromFile.ConvertedType;
+                newFile.Comment = string.Format(FilesCommonResource.CommentRevert, fromFile.ModifiedOnString);
+                newFile.Encrypted = fromFile.Encrypted;
+
+                using (var stream = fileDao.GetFileStream(fromFile))
+                {
+                    newFile.ContentLength = stream.CanSeek ? stream.Length : fromFile.ContentLength;
+                    newFile = fileDao.SaveFile(newFile, stream);
+                }
+
+                FileMarker.MarkAsNew(newFile);
+
+                SetFileStatus(newFile);
+
+                return newFile;
+            }
+            catch (Exception e)
+            {
+                Logger.Error(string.Format("Error on update {0} to version {1}", fileId, version), e);
+                throw new Exception(e.Message, e);
+            }
+            finally
+            {
+                cache.Remove(UPDATE_LIST + fromFile.ID);
+            }
+        }
+
         public File CompleteVersionFile(object fileId, int version, bool continueVersion, bool checkRight = true)
         {
             var fileDao = DaoFactory.FileDao;
@@ -949,6 +1163,47 @@ namespace ASC.Web.Files.Utils
             return lastVersionFile;
         }
 
+        public File<T> CompleteVersionFile<T>(T fileId, int version, bool continueVersion, bool checkRight = true)
+        {
+            var fileDao = DaoFactory.GetFileDao<T>();
+            var fileVersion = version > 0
+? fileDao.GetFile(fileId, version)
+: fileDao.GetFile(fileId);
+            if (fileVersion == null) throw new FileNotFoundException(FilesCommonResource.ErrorMassage_FileNotFound);
+            if (checkRight && (!FileSecurity.CanEdit(fileVersion) || UserManager.GetUsers(AuthContext.CurrentAccount.ID).IsVisitor(UserManager))) throw new SecurityException(FilesCommonResource.ErrorMassage_SecurityException_EditFile);
+            if (FileLockedForMe(fileVersion.ID)) throw new Exception(FilesCommonResource.ErrorMassage_LockedFile);
+            if (fileVersion.RootFolderType == FolderType.TRASH) throw new Exception(FilesCommonResource.ErrorMassage_ViewTrashItem);
+            if (fileVersion.ProviderEntry) throw new Exception(FilesCommonResource.ErrorMassage_BadRequest);
+
+            var lastVersionFile = fileDao.GetFile(fileVersion.ID);
+
+            if (continueVersion)
+            {
+                if (lastVersionFile.VersionGroup > 1)
+                {
+                    fileDao.ContinueVersion(fileVersion.ID, fileVersion.Version);
+                    lastVersionFile.VersionGroup--;
+                }
+            }
+            else
+            {
+                if (!FileTracker.IsEditing(lastVersionFile.ID))
+                {
+                    if (fileVersion.Version == lastVersionFile.Version)
+                    {
+                        lastVersionFile = UpdateToVersionFile(fileVersion.ID, fileVersion.Version, null, checkRight);
+                    }
+
+                    fileDao.CompleteVersion(fileVersion.ID, fileVersion.Version);
+                    lastVersionFile.VersionGroup++;
+                }
+            }
+
+            SetFileStatus(lastVersionFile);
+
+            return lastVersionFile;
+        }
+
         public bool FileRename(object fileId, string title, out File file)
         {
             var fileDao = DaoFactory.FileDao;
@@ -1009,6 +1264,24 @@ namespace ASC.Web.Files.Utils
             }
         }
 
+        public void DeleteSubitems<T>(T parentId, IFolderDao<T> folderDao, IFileDao<T> fileDao)
+        {
+            var folders = folderDao.GetFolders(parentId);
+            foreach (var folder in folders)
+            {
+                DeleteSubitems<T>(folder.ID, folderDao, fileDao);
+
+                Logger.InfoFormat("Delete folder {0} in {1}", folder.ID, parentId);
+                folderDao.DeleteFolder(folder.ID);
+            }
+
+            var files = fileDao.GetFiles(parentId, null, FilterType.None, false, Guid.Empty, string.Empty, true);
+            foreach (var file in files)
+            {
+                Logger.InfoFormat("Delete file {0} in {1}", file.ID, parentId);
+                fileDao.DeleteFile(file.ID);
+            }
+        }
         public void MoveSharedItems(object parentId, object toId, IFolderDao folderDao, IFileDao fileDao)
         {
             var fileSecurity = FileSecurity;
@@ -1043,7 +1316,41 @@ namespace ASC.Web.Files.Utils
             }
         }
 
-        public static void ReassignItems(object parentId, Guid fromUserId, Guid toUserId, IFolderDao folderDao, IFileDao fileDao)
+        public void MoveSharedItems<T>(T parentId, T toId, IFolderDao<T> folderDao, IFileDao<T> fileDao)
+        {
+            var fileSecurity = FileSecurity;
+
+            var folders = folderDao.GetFolders(parentId);
+            foreach (var folder in folders)
+            {
+                var shared = folder.Shared
+                             && fileSecurity.GetShares(folder).Any(record => record.Share != FileShare.Restrict);
+                if (shared)
+                {
+                    Logger.InfoFormat("Move shared folder {0} from {1} to {2}", folder.ID, parentId, toId);
+                    folderDao.MoveFolder(folder.ID, toId, null);
+                }
+                else
+                {
+                    MoveSharedItems(folder.ID, toId, folderDao, fileDao);
+                }
+            }
+
+            var files = fileDao.GetFiles(parentId, null, FilterType.None, false, Guid.Empty, string.Empty, true);
+            foreach (var file
+                in files.Where(file =>
+                               file.Shared
+                               && fileSecurity.GetShares(file)
+                                              .Any(record =>
+                                                   record.Subject != FileConstant.ShareLinkId
+                                                   && record.Share != FileShare.Restrict)))
+            {
+                Logger.InfoFormat("Move shared file {0} from {1} to {2}", file.ID, parentId, toId);
+                fileDao.MoveFile(file.ID, toId);
+            }
+        }
+
+        public static void ReassignItems<T>(T parentId, Guid fromUserId, Guid toUserId, IFolderDao<T> folderDao, IFileDao<T> fileDao)
         {
             var fileIds = fileDao.GetFiles(parentId, new OrderBy(SortedByType.AZ, true), FilterType.ByUser, false, fromUserId, null, true, true)
                                  .Where(file => file.CreateBy == fromUserId).Select(file => file.ID);

products/ASC.Files/Server/Utils/FileConverter.cs

@@ -318,7 +318,7 @@ namespace ASC.Web.Files.Utils
             return result != null && result.Progress != 100 && string.IsNullOrEmpty(result.Error);
         }
 
-        public IEnumerable<FileOperationResult> GetStatus(IEnumerable<KeyValuePair<File, bool>> filesPair)
+        public IEnumerable<FileOperationResult> GetStatus<T>(IEnumerable<KeyValuePair<File<T>, bool>> filesPair)
         {
             var fileSecurity = FileSecurity;
             var result = new List<FileOperationResult>();

products/ASC.Files/Server/Utils/FileShareLink.cs

@@ -86,6 +86,10 @@ namespace ASC.Web.Files.Utils
         {
             return Signature.Read<string>(doc ?? string.Empty, Global.GetDocDbKey());
         }
+        public T Parse<T>(string doc)
+        {
+            return Signature.Read<T>(doc ?? string.Empty, Global.GetDocDbKey());
+        }
 
         public bool Check(string doc, bool checkRead, IFileDao fileDao, out File file)
         {
@@ -93,6 +97,12 @@ namespace ASC.Web.Files.Utils
             return (!checkRead && (fileShare == FileShare.ReadWrite || fileShare == FileShare.Review || fileShare == FileShare.FillForms || fileShare == FileShare.Comment))
                 || (checkRead && fileShare != FileShare.Restrict);
         }
+        public bool Check<T>(string doc, bool checkRead, IFileDao<T> fileDao, out File<T> file)
+        {
+            var fileShare = Check(doc, fileDao, out file);
+            return (!checkRead && (fileShare == FileShare.ReadWrite || fileShare == FileShare.Review || fileShare == FileShare.FillForms || fileShare == FileShare.Comment))
+                || (checkRead && fileShare != FileShare.Restrict);
+        }
 
         public FileShare Check(string doc, IFileDao fileDao, out File file)
         {
@@ -110,6 +120,23 @@ namespace ASC.Web.Files.Utils
             if (filesSecurity.CanRead(file, FileConstant.ShareLinkId)) return FileShare.Read;
             return FileShare.Restrict;
         }
+
+        public FileShare Check<T>(string doc, IFileDao<T> fileDao, out File<T> file)
+        {
+            file = null;
+            if (string.IsNullOrEmpty(doc)) return FileShare.Restrict;
+            var fileId = Parse<T>(doc);
+            file = fileDao.GetFile(fileId);
+            if (file == null) return FileShare.Restrict;
+
+            var filesSecurity = FileSecurity;
+            if (filesSecurity.CanEdit(file, FileConstant.ShareLinkId)) return FileShare.ReadWrite;
+            if (filesSecurity.CanReview(file, FileConstant.ShareLinkId)) return FileShare.Review;
+            if (filesSecurity.CanFillForms(file, FileConstant.ShareLinkId)) return FileShare.FillForms;
+            if (filesSecurity.CanComment(file, FileConstant.ShareLinkId)) return FileShare.Comment;
+            if (filesSecurity.CanRead(file, FileConstant.ShareLinkId)) return FileShare.Read;
+            return FileShare.Restrict;
+        }
     }
     public static class FileShareLinkExtension
     {

products/ASC.Files/Server/Utils/FileTracker.cs

@@ -164,6 +164,31 @@ namespace ASC.Web.Files.Utils
             return false;
         }
 
+        public static bool IsEditing<T>(T fileId)
+        {
+            var tracker = GetTracker(fileId);
+            if (tracker != null)
+            {
+                var listForRemove = tracker._editingBy
+                                           .Where(e => !e.Value.NewScheme && (DateTime.UtcNow - e.Value.TrackTime).Duration() > TrackTimeout)
+                                           .ToList();
+                foreach (var editTab in listForRemove)
+                {
+                    tracker._editingBy.Remove(editTab.Key);
+                }
+
+                if (tracker._editingBy.Count == 0)
+                {
+                    SetTracker(fileId, null);
+                    return false;
+                }
+
+                SetTracker(fileId, tracker);
+                return true;
+            }
+            SetTracker(fileId, null);
+            return false;
+        }
         public static bool IsEditingAlone(object fileId)
         {
             var tracker = GetTracker(fileId);

products/ASC.Files/Server/Utils/FileUploader.cs

@@ -248,21 +248,15 @@ namespace ASC.Web.Files.Utils
             return file;
         }
 
-        public ChunkedUploadSession InitiateUpload(string folderId, string fileId, string fileName, long contentLength, bool encrypted)
+        public ChunkedUploadSession<T> InitiateUpload<T>(T folderId, T fileId, string fileName, long contentLength, bool encrypted)
         {
-            if (string.IsNullOrEmpty(folderId))
-                folderId = null;
-
-            if (string.IsNullOrEmpty(fileId))
-                fileId = null;
-
-            var file = ServiceProvider.GetService<File>();
+            var file = ServiceProvider.GetService<File<T>>();
             file.ID = fileId;
             file.FolderID = folderId;
             file.Title = fileName;
             file.ContentLength = contentLength;
 
-            var dao = DaoFactory.FileDao;
+            var dao = DaoFactory.GetFileDao<T>();
             var uploadSession = dao.CreateUploadSession(file, contentLength);
 
             uploadSession.Expired = uploadSession.Created + ChunkedUploadSessionHolder.SlidingExpiration;
@@ -278,9 +272,9 @@ namespace ASC.Web.Files.Utils
             return uploadSession;
         }
 
-        public ChunkedUploadSession UploadChunk(string uploadId, Stream stream, long chunkLength)
+        public ChunkedUploadSession<T> UploadChunk<T>(string uploadId, Stream stream, long chunkLength)
         {
-            var uploadSession = ChunkedUploadSessionHolder.GetSession(uploadId);
+            var uploadSession = ChunkedUploadSessionHolder.GetSession<T>(uploadId);
             uploadSession.Expired = DateTime.UtcNow + ChunkedUploadSessionHolder.SlidingExpiration;
 
             if (chunkLength <= 0)
@@ -301,7 +295,7 @@ namespace ASC.Web.Files.Utils
                 throw FileSizeComment.GetFileSizeException(maxUploadSize);
             }
 
-            var dao = DaoFactory.FileDao;
+            var dao = DaoFactory.GetFileDao<T>();
             dao.UploadChunk(uploadSession, stream, chunkLength);
 
             if (uploadSession.BytesUploaded == uploadSession.BytesTotal)
@@ -317,14 +311,14 @@ namespace ASC.Web.Files.Utils
             return uploadSession;
         }
 
-        public void AbortUpload(string uploadId)
+        public void AbortUpload<T>(string uploadId)
         {
-            AbortUpload(ChunkedUploadSessionHolder.GetSession(uploadId));
+            AbortUpload(ChunkedUploadSessionHolder.GetSession<T>(uploadId));
         }
 
-        private void AbortUpload(ChunkedUploadSession uploadSession)
+        private void AbortUpload<T>(ChunkedUploadSession<T> uploadSession)
         {
-            DaoFactory.FileDao.AbortUploadSession(uploadSession);
+            DaoFactory.GetFileDao<T>().AbortUploadSession(uploadSession);
 
             ChunkedUploadSessionHolder.RemoveSession(uploadSession);
         }