Merge pull request #25945 from abpframework/maliming/delete-user-password-histories-passkeys

Remove all related data when deleting a user

Author: EngincanV

framework/src/Volo.Abp.Gdpr.Abstractions/Volo.Abp.Gdpr.Abstractions.csproj

@@ -12,6 +12,7 @@
 
     <ItemGroup>
         <ProjectReference Include="..\Volo.Abp.Core\Volo.Abp.Core.csproj" />
+        <ProjectReference Include="..\Volo.Abp.EventBus.Abstractions\Volo.Abp.EventBus.Abstractions.csproj" />
     </ItemGroup>
 
 </Project>

framework/src/Volo.Abp.Gdpr.Abstractions/Volo/Abp/Gdpr/AbpGdprAbstractionsModule.cs

@@ -1,7 +1,11 @@
 using Volo.Abp.Modularity;
+using Volo.Abp.EventBus.Abstractions;
 
 namespace Volo.Abp.Gdpr;
 
+[DependsOn(
+    typeof(AbpEventBusAbstractionsModule)
+)]
 public class AbpGdprAbstractionsModule : AbpModule
 {
 }

framework/src/Volo.Abp.Gdpr.Abstractions/Volo/Abp/Gdpr/GdprUserDataDeletionRequestedEto.cs

@@ -1,9 +1,18 @@
 using System;
+using Volo.Abp.EventBus;
 
 namespace Volo.Abp.Gdpr;
 
 [Serializable]
-public class GdprUserDataDeletionRequestedEto
+public class GdprUserDataDeletionRequestedEto : IEventDataMayHaveTenantId
 {
+    public Guid? TenantId { get; set; }
+
     public Guid UserId { get; set; }
-}
+
+    public bool IsMultiTenant(out Guid? tenantId)
+    {
+        tenantId = TenantId;
+        return TenantId.HasValue;
+    }
+}

framework/src/Volo.Abp.Gdpr.Abstractions/Volo/Abp/Gdpr/GdprUserDataPreparedEto.cs

@@ -1,13 +1,22 @@
 using System;
+using Volo.Abp.EventBus;
 
 namespace Volo.Abp.Gdpr;
 
 [Serializable]
-public class GdprUserDataPreparedEto
+public class GdprUserDataPreparedEto : IEventDataMayHaveTenantId
 {
+    public Guid? TenantId { get; set; }
+
     public Guid RequestId { get; set; }
 
     public string Provider { get; set; } = default!;
 
     public GdprDataInfo Data { get; set; } = default!;
-}
+
+    public bool IsMultiTenant(out Guid? tenantId)
+    {
+        tenantId = TenantId;
+        return TenantId.HasValue;
+    }
+}

framework/src/Volo.Abp.Gdpr.Abstractions/Volo/Abp/Gdpr/GdprUserDataRequestedEto.cs

@@ -1,11 +1,20 @@
 using System;
+using Volo.Abp.EventBus;
 
 namespace Volo.Abp.Gdpr;
 
 [Serializable]
-public class GdprUserDataRequestedEto
+public class GdprUserDataRequestedEto : IEventDataMayHaveTenantId
 {
+    public Guid? TenantId { get; set; }
+
     public Guid UserId { get; set; }
 
     public Guid RequestId { get; set; }
-}
+
+    public bool IsMultiTenant(out Guid? tenantId)
+    {
+        tenantId = TenantId;
+        return TenantId.HasValue;
+    }
+}

modules/identity/src/Volo.Abp.Identity.Domain/Volo/Abp/Identity/IdentityUserManager.cs

@@ -98,13 +98,32 @@ public virtual async Task<IdentityResult> CreateAsync(IdentityUser user, string
 
     public async override Task<IdentityResult> DeleteAsync(IdentityUser user)
     {
+        //The user may have been loaded without details.
+        await UserRepository.EnsureCollectionLoadedAsync(user, x => x.Claims, CancellationToken);
+        await UserRepository.EnsureCollectionLoadedAsync(user, x => x.Roles, CancellationToken);
+        await UserRepository.EnsureCollectionLoadedAsync(user, x => x.Tokens, CancellationToken);
+        await UserRepository.EnsureCollectionLoadedAsync(user, x => x.Logins, CancellationToken);
+        await UserRepository.EnsureCollectionLoadedAsync(user, x => x.OrganizationUnits, CancellationToken);
+        await UserRepository.EnsureCollectionLoadedAsync(user, x => x.PasswordHistories, CancellationToken);
+        await UserRepository.EnsureCollectionLoadedAsync(user, x => x.Passkeys, CancellationToken);
+
         user.Claims.Clear();
         user.Roles.Clear();
         user.Tokens.Clear();
         user.Logins.Clear();
         user.OrganizationUnits.Clear();
-        await IdentityLinkUserRepository.DeleteAsync(new IdentityLinkUserInfo(user.Id, user.TenantId), CancellationToken);
-        await UpdateAsync(user);
+        user.PasswordHistories.Clear();
+        user.Passkeys.Clear();
+
+        //Soft deleting reloads the original values, the store saves the changes without validating the user.
+        //Nothing else is deleted before this succeeds, it is where the user is checked for concurrency.
+        (await Store.UpdateAsync(user, CancellationToken)).CheckErrors();
+
+        //They are in the host database and deleting them here covers the current unit of work.
+        using (CurrentTenant.Change(null))
+        {
+            await IdentityLinkUserRepository.DeleteAsync(new IdentityLinkUserInfo(user.Id, user.TenantId), CancellationToken);
+        }
 
         return await base.DeleteAsync(user);
     }

modules/identity/src/Volo.Abp.Identity.Domain/Volo/Abp/Identity/OrganizationUnitManager.cs

@@ -48,6 +48,51 @@ public virtual async Task CreateAsync(OrganizationUnit organizationUnit)
         await OrganizationUnitRepository.InsertAsync(organizationUnit);
     }
 
+    /// <summary>
+    /// Creates the given organization units by querying the siblings of a parent once instead of once
+    /// per organization unit. They all have to belong to the current tenant and their parents must
+    /// already exist. <see cref="GetNextChildCodeAsync"/> is used for the first organization unit of a
+    /// parent, the codes of the rest follow it. Custom validation should be added by overriding
+    /// <see cref="ValidateOrganizationUnitAsync(OrganizationUnit, List{OrganizationUnit})"/>.
+    /// </summary>
+    [UnitOfWork]
+    public virtual async Task CreateManyAsync(List<OrganizationUnit> organizationUnits)
+    {
+        Check.NotNull(organizationUnits, nameof(organizationUnits));
+
+        if (organizationUnits.Any(x => x.TenantId != CurrentTenant.Id))
+        {
+            throw new AbpException("Organization units of another tenant can not be created, change the current tenant instead!");
+        }
+
+        var groups = organizationUnits.GroupBy(x => x.ParentId).ToList();
+
+        foreach (var group in groups)
+        {
+            await ValidateParentTenantAsync(group.Key, CurrentTenant.Id);
+
+            var siblings = await FindChildrenAsync(group.Key);
+            string lastCode = null;
+
+            foreach (var organizationUnit in group)
+            {
+                organizationUnit.Code = lastCode = lastCode == null
+                    ? await GetNextChildCodeAsync(group.Key)
+                    : OrganizationUnit.CalculateNextCode(lastCode);
+
+                await ValidateOrganizationUnitAsync(organizationUnit, siblings);
+
+                siblings.Add(organizationUnit);
+            }
+        }
+
+        //Nothing is inserted before every group is validated.
+        foreach (var group in groups)
+        {
+            await OrganizationUnitRepository.InsertManyAsync(group.ToList());
+        }
+    }
+
     public virtual async Task UpdateAsync(OrganizationUnit organizationUnit)
     {
         await ValidateOrganizationUnitAsync(organizationUnit);
@@ -141,15 +186,21 @@ public virtual async Task<string> GetCodeOrDefaultAsync(Guid id)
 
     protected virtual async Task ValidateOrganizationUnitAsync(OrganizationUnit organizationUnit)
     {
-        var siblings = (await FindChildrenAsync(organizationUnit.ParentId))
-            .Where(ou => ou.Id != organizationUnit.Id)
-            .ToList();
+        await ValidateOrganizationUnitAsync(organizationUnit, await FindChildrenAsync(organizationUnit.ParentId));
+    }
 
-        if (siblings.Any(ou => ou.DisplayName == organizationUnit.DisplayName))
+    /// <summary>
+    /// Validates the organization unit against the given siblings, so they are not queried again.
+    /// </summary>
+    protected virtual Task ValidateOrganizationUnitAsync(OrganizationUnit organizationUnit, List<OrganizationUnit> siblings)
+    {
+        if (siblings.Any(ou => ou.Id != organizationUnit.Id && ou.DisplayName == organizationUnit.DisplayName))
         {
             throw new BusinessException(IdentityErrorCodes.DuplicateOrganizationUnitDisplayName)
                 .WithData("0", organizationUnit.DisplayName);
         }
+
+        return Task.CompletedTask;
     }
 
     protected virtual async Task ValidateParentTenantAsync(Guid? parentId, Guid? tenantId)

modules/identity/src/Volo.Abp.Identity.Domain/Volo/Abp/Identity/UserDeletedEventHandler.cs

@@ -0,0 +1,52 @@
+using System.Linq;
+using System.Threading.Tasks;
+using Volo.Abp.DependencyInjection;
+using Volo.Abp.Domain.Entities.Events;
+using Volo.Abp.EventBus;
+using Volo.Abp.MultiTenancy;
+using Volo.Abp.Uow;
+
+namespace Volo.Abp.Identity;
+
+//Sessions, user delegations and link users have no navigation from IdentityUser,
+//so clearing the user's collections doesn't cover them.
+public class UserDeletedEventHandler :
+    ILocalEventHandler<EntityDeletedEventData<IdentityUser>>,
+    ITransientDependency
+{
+    protected IIdentitySessionRepository IdentitySessionRepository { get; }
+    protected IIdentityUserDelegationRepository IdentityUserDelegationRepository { get; }
+    protected IIdentityLinkUserRepository IdentityLinkUserRepository { get; }
+    protected ICurrentTenant CurrentTenant { get; }
+
+    public UserDeletedEventHandler(
+        IIdentitySessionRepository identitySessionRepository,
+        IIdentityUserDelegationRepository identityUserDelegationRepository,
+        IIdentityLinkUserRepository identityLinkUserRepository,
+        ICurrentTenant currentTenant)
+    {
+        IdentitySessionRepository = identitySessionRepository;
+        IdentityUserDelegationRepository = identityUserDelegationRepository;
+        IdentityLinkUserRepository = identityLinkUserRepository;
+        CurrentTenant = currentTenant;
+    }
+
+    [UnitOfWork]
+    public virtual async Task HandleEventAsync(EntityDeletedEventData<IdentityUser> eventData)
+    {
+        var user = eventData.Entity;
+
+        await IdentitySessionRepository.DeleteAllAsync(user.Id);
+
+        var delegations = await IdentityUserDelegationRepository.GetListAsync(sourceUserId: user.Id, targetUserId: null);
+        delegations.AddRange(await IdentityUserDelegationRepository.GetListAsync(sourceUserId: null, targetUserId: user.Id));
+        //A delegation of the user to itself is returned by both queries.
+        await IdentityUserDelegationRepository.DeleteManyAsync(delegations.DistinctBy(x => x.Id).ToList());
+
+        //Link users are stored in the host database.
+        using (CurrentTenant.Change(null))
+        {
+            await IdentityLinkUserRepository.DeleteAsync(new IdentityLinkUserInfo(user.Id, user.TenantId));
+        }
+    }
+}

modules/identity/test/Volo.Abp.Identity.Domain.Tests/Volo/Abp/Identity/IdentityUserManager_Delete_Tests.cs

@@ -0,0 +1,5 @@
+namespace Volo.Abp.Identity;
+
+public class IdentityUserManager_Delete_Tests : IdentityUserManager_Delete_Tests<AbpIdentityDomainTestModule>
+{
+}

modules/identity/test/Volo.Abp.Identity.Domain.Tests/Volo/Abp/Identity/OrganizationUnitManager_CreateMany_Tests.cs

@@ -0,0 +1,5 @@
+namespace Volo.Abp.Identity;
+
+public class OrganizationUnitManager_CreateMany_Tests : OrganizationUnitManager_CreateMany_Tests<AbpIdentityDomainTestModule>
+{
+}