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

ASC.Data.Reassigns: splited the ReassignStorageAsync method into parts

Browse Source
This commit is contained in:
Andrey Savihin 2023-07-12 13:34:30 +03:00
parent 6e9e3e07f8
commit 0026f990fd
4 changed files with 132 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
common/ASC.Data.Reassigns/ReassignProgressItem.cs
View File

@ -78,17 +78,37 @@ public class ReassignProgressItem : DistributedTaskProgress
await securityContext.AuthenticateMeWithoutCookieAsync(_currentUserId);
Percentage = 33;
Percentage = 5;
PublishChanges();
await fileStorageService.ReassignStorageAsync<int>(FromUser, ToUser);
await fileStorageService.DemandPermissionToReassignDataAsync(FromUser, ToUser);
Percentage = 66;
Percentage = 10;
PublishChanges();
await fileStorageService.DeletePersonalDataAsync<int>(FromUser);
Percentage = 30;
PublishChanges();
await fileStorageService.ReassignProvidersAsync<string>(FromUser, ToUser);
Percentage = 50;
PublishChanges();
await fileStorageService.ReassignFoldersAsync<int>(FromUser, ToUser);
Percentage = 70;
PublishChanges();
await fileStorageService.ReassignFilesAsync<int>(FromUser, ToUser);
Percentage = 90;
PublishChanges();
await SendSuccessNotifyAsync(userManager, studioNotifyService, messageService, messageTarget, displayUserSettingsHelper);
Percentage = 99;
Percentage = 95;
PublishChanges();
if (_deleteProfile)

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

@ -2220,55 +2220,126 @@ public class FileStorageService //: IFileStorageService
return _filesLinkUtility.GetFileWebEditorUrl(file.Id);
}
public async Task ReassignStorageAsync<T>(Guid userFromId, Guid userToId)
#region [Reassign|Delete] Data Manager
public async Task DemandPermissionToReassignDataAsync(Guid userFromId, Guid userToId)
{
await DemandPermissionToDeletePersonalDataAsync(userFromId);
//check exist userTo
var userTo = await _userManager.GetUsersAsync(userToId);
ErrorIf(Equals(userTo, Constants.LostUser), FilesCommonResource.ErrorMassage_UserNotFound);
//check user can have personal data
ErrorIf(await _userManager.IsUserAsync(userTo), FilesCommonResource.ErrorMassage_SecurityException);
}
public async Task DemandPermissionToDeletePersonalDataAsync(Guid userFromId)
{
var userFrom = await _userManager.GetUsersAsync(userFromId);
await DemandPermissionToDeletePersonalDataAsync(userFrom);
}
public async Task DemandPermissionToDeletePersonalDataAsync(UserInfo userFrom)
{
//check current user have access
ErrorIf(!await _global.IsDocSpaceAdministratorAsync, FilesCommonResource.ErrorMassage_SecurityException);
//check exist userFrom
var userFrom = await _userManager.GetUsersAsync(userFromId);
ErrorIf(Equals(userFrom, Constants.LostUser), FilesCommonResource.ErrorMassage_UserNotFound);
//check exist userTo
var userTo = await _userManager.GetUsersAsync(userToId);
ErrorIf(Equals(userTo, Constants.LostUser), FilesCommonResource.ErrorMassage_UserNotFound);
ErrorIf(await _userManager.IsUserAsync(userTo), FilesCommonResource.ErrorMassage_SecurityException);
//check user have personal data
ErrorIf(await _userManager.IsUserAsync(userFrom), FilesCommonResource.ErrorMassage_SecurityException);
}
var providerDao = GetProviderDao<T>();
if (providerDao != null)
public async Task DeletePersonalDataAsync<T>(Guid userFromId, bool checkPermission = false)
{
if (checkPermission)
{
//move thirdparty storage userFrom
await foreach (var commonProviderInfo in providerDao.GetProvidersInfoAsync(userFrom.Id))
{
_logger.InformationReassignProvider(commonProviderInfo.ProviderId, userFrom.Id, userTo.Id);
await providerDao.UpdateProviderInfoAsync(commonProviderInfo.ProviderId, null, null, FolderType.DEFAULT, userTo.Id);
}
await DemandPermissionToDeletePersonalDataAsync(userFromId);
}
var folderDao = GetFolderDao<T>();
var fileDao = GetFileDao<T>();
if (!await _userManager.IsUserAsync(userFrom))
if (folderDao == null)
{
_logger.InformationDeletePersonalData(userFrom.Id);
var folderIdFromMy = await folderDao.GetFolderIDUserAsync(false, userFrom.Id);
if (!Equals(folderIdFromMy, 0))
{
await folderDao.DeleteFolderAsync(folderIdFromMy);
}
var folderIdFromTrash = await folderDao.GetFolderIDTrashAsync(false, userFrom.Id);
if (!Equals(folderIdFromTrash, 0))
{
await folderDao.DeleteFolderAsync(folderIdFromTrash);
}
return;
}
_logger.InformationReassignData(userFrom.Id, userTo.Id);
await EntryManager.ReassignItemsAsync(userFrom.Id, userTo.Id, folderDao, fileDao);
_logger.InformationDeletePersonalData(userFromId);
var folderIdFromMy = await folderDao.GetFolderIDUserAsync(false, userFromId);
if (!Equals(folderIdFromMy, 0))
{
await folderDao.DeleteFolderAsync(folderIdFromMy);
}
var folderIdFromTrash = await folderDao.GetFolderIDTrashAsync(false, userFromId);
if (!Equals(folderIdFromTrash, 0))
{
await folderDao.DeleteFolderAsync(folderIdFromTrash);
}
}
public async Task ReassignProvidersAsync<T>(Guid userFromId, Guid userToId, bool checkPermission = false)
{
if (checkPermission)
{
await DemandPermissionToReassignDataAsync(userFromId, userToId);
}
var providerDao = GetProviderDao<T>();
if (providerDao == null)
{
return;
}
//move thirdparty storage userFrom
await foreach (var commonProviderInfo in providerDao.GetProvidersInfoAsync(userFromId))
{
_logger.InformationReassignProvider(commonProviderInfo.ProviderId, userFromId, userToId);
await providerDao.UpdateProviderInfoAsync(commonProviderInfo.ProviderId, null, null, FolderType.DEFAULT, userToId);
}
}
public async Task ReassignFoldersAsync<T>(Guid userFromId, Guid userToId, bool checkPermission = false)
{
if (checkPermission)
{
await DemandPermissionToReassignDataAsync(userFromId, userToId);
}
var folderDao = GetFolderDao<T>();
if (folderDao == null)
{
return;
}
_logger.InformationReassignFolders(userFromId, userToId);
await folderDao.ReassignFoldersAsync(userFromId, userToId);
}
public async Task ReassignFilesAsync<T>(Guid userFromId, Guid userToId, bool checkPermission = false)
{
if (checkPermission)
{
await DemandPermissionToReassignDataAsync(userFromId, userToId);
}
var fileDao = GetFileDao<T>();
if (fileDao == null)
{
return;
}
_logger.InformationReassignFiles(userFromId, userToId);
await fileDao.ReassignFilesAsync(userFromId, userToId);
}
#endregion
#region Favorites Manager
public async Task<bool> ToggleFileFavoriteAsync<T>(T fileId, bool favorite)

7
products/ASC.Files/Core/Log/FileStorageServiceLogger.cs
View File

@ -42,8 +42,11 @@ internal static partial class FileStorageServiceLogger
[LoggerMessage(Level = LogLevel.Information, Message = "Delete provider {providerId} for {userId}")]
public static partial void InformationDeleteProvider(this ILogger logger, int providerId, Guid userId);
[LoggerMessage(Level = LogLevel.Information, Message = "Reassign data from {fromUser} to {toUser}")]
public static partial void InformationReassignData(this ILogger logger, Guid fromUser, Guid toUser);
[LoggerMessage(Level = LogLevel.Information, Message = "Reassign folders from {fromUser} to {toUser}")]
public static partial void InformationReassignFolders(this ILogger logger, Guid fromUser, Guid toUser);
[LoggerMessage(Level = LogLevel.Information, Message = "Reassign files from {fromUser} to {toUser}")]
public static partial void InformationReassignFiles(this ILogger logger, Guid fromUser, Guid toUser);
[LoggerMessage(Level = LogLevel.Information, Message = "Delete personal data for {userId}")]
public static partial void InformationDeletePersonalData(this ILogger logger, Guid userId);

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

@ -1954,11 +1954,4 @@ public class EntryManager
await fileDao.MoveFileAsync(file.Id, toId);
}
}
public static async Task ReassignItemsAsync<T>(Guid fromUserId, Guid toUserId, IFolderDao<T> folderDao, IFileDao<T> fileDao)
{
await fileDao.ReassignFilesAsync(fromUserId, toUserId);
await folderDao.ReassignFoldersAsync(fromUserId, toUserId);
}
}