Merge pull request #18051 from abpframework/issue-18042

Remove Permissions and other user-related data when deleting a user.

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

@@ -8,7 +8,7 @@ public class IdentityLinkUserInfo
 
     public virtual Guid? TenantId { get; set; }
 
-    public IdentityLinkUserInfo(Guid userId, Guid? tenantId)
+    public IdentityLinkUserInfo(Guid userId, Guid? tenantId = null)
     {
         UserId = userId;
         TenantId = tenantId;

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

@@ -11,10 +11,10 @@ using Volo.Abp.Domain.Entities;
 using Volo.Abp.Domain.Repositories;
 using Volo.Abp.Domain.Services;
 using Volo.Abp.EventBus.Distributed;
+using Volo.Abp.EventBus.Local;
 using Volo.Abp.Identity.Settings;
 using Volo.Abp.Settings;
 using Volo.Abp.Threading;
-using Volo.Abp.Timing;
 using Volo.Abp.Uow;
 
 namespace Volo.Abp.Identity;
@@ -27,7 +27,7 @@ public class IdentityUserManager : UserManager<IdentityUser>, IDomainService
     protected ISettingProvider SettingProvider { get; }
     protected ICancellationTokenProvider CancellationTokenProvider { get; }
     protected IDistributedEventBus DistributedEventBus { get; }
-
+    protected IIdentityLinkUserRepository IdentityLinkUserRepository { get; }
     protected override CancellationToken CancellationToken => CancellationTokenProvider.Token;
 
     public IdentityUserManager(
@@ -45,7 +45,8 @@ public class IdentityUserManager : UserManager<IdentityUser>, IDomainService
         ICancellationTokenProvider cancellationTokenProvider,
         IOrganizationUnitRepository organizationUnitRepository,
         ISettingProvider settingProvider,
-        IDistributedEventBus distributedEventBus)
+        IDistributedEventBus distributedEventBus,
+        IIdentityLinkUserRepository identityLinkUserRepository)
         : base(
             store,
             optionsAccessor,
@@ -62,6 +63,7 @@ public class IdentityUserManager : UserManager<IdentityUser>, IDomainService
         DistributedEventBus = distributedEventBus;
         RoleRepository = roleRepository;
         UserRepository = userRepository;
+        IdentityLinkUserRepository = identityLinkUserRepository;
         CancellationTokenProvider = cancellationTokenProvider;
     }
 
@@ -76,6 +78,19 @@ public class IdentityUserManager : UserManager<IdentityUser>, IDomainService
         return await CreateAsync(user);
     }
 
+    public async override Task<IdentityResult> DeleteAsync(IdentityUser user)
+    {
+        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);
+
+        return await base.DeleteAsync(user);
+    }
+
     public virtual async Task<IdentityUser> GetByIdAsync(Guid id)
     {
         var user = await Store.FindByIdAsync(id.ToString(), CancellationToken);

modules/identity/src/Volo.Abp.PermissionManagement.Domain.Identity/Volo.Abp.PermissionManagement.Domain.Identity.csproj

@@ -16,6 +16,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\Volo.Abp.Identity.Domain.Shared\Volo.Abp.Identity.Domain.Shared.csproj" />
+    <ProjectReference Include="..\..\..\users\src\Volo.Abp.Users.Abstractions\Volo.Abp.Users.Abstractions.csproj" />
     <ProjectReference Include="..\..\..\permission-management\src\Volo.Abp.PermissionManagement.Domain\Volo.Abp.PermissionManagement.Domain.csproj" />
   </ItemGroup>
 

modules/identity/src/Volo.Abp.PermissionManagement.Domain.Identity/Volo/Abp/PermissionManagement/Identity/AbpPermissionManagementDomainIdentityModule.cs

@@ -1,13 +1,15 @@
 using Volo.Abp.Authorization.Permissions;
 using Volo.Abp.Identity;
 using Volo.Abp.Modularity;
+using Volo.Abp.Users;
 
 namespace Volo.Abp.PermissionManagement.Identity;
 
 [DependsOn(
     typeof(AbpIdentityDomainSharedModule),
-    typeof(AbpPermissionManagementDomainModule)
+    typeof(AbpPermissionManagementDomainModule),
-    )]
+    typeof(AbpUsersAbstractionModule)
+)]
 public class AbpPermissionManagementDomainIdentityModule : AbpModule
 {
     public override void ConfigureServices(ServiceConfigurationContext context)

modules/identity/src/Volo.Abp.PermissionManagement.Domain.Identity/Volo/Abp/PermissionManagement/Identity/RoleDeletedEventHandler.cs

@@ -5,6 +5,7 @@ using Volo.Abp.Domain.Entities.Events.Distributed;
 using Volo.Abp.EventBus;
 using Volo.Abp.EventBus.Distributed;
 using Volo.Abp.Identity;
+using Volo.Abp.Uow;
 
 namespace Volo.Abp.PermissionManagement.Identity;
 
@@ -19,7 +20,8 @@ public class RoleDeletedEventHandler :
         PermissionManager = permissionManager;
     }
 
-    public async Task HandleEventAsync(EntityDeletedEto<IdentityRoleEto> eventData)
+    [UnitOfWork]
+    public virtual async Task HandleEventAsync(EntityDeletedEto<IdentityRoleEto> eventData)
     {
         await PermissionManager.DeleteAsync(RolePermissionValueProvider.ProviderName, eventData.Entity.Name);
     }

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

@@ -0,0 +1,27 @@
+using System.Threading.Tasks;
+using Volo.Abp.Authorization.Permissions;
+using Volo.Abp.DependencyInjection;
+using Volo.Abp.Domain.Entities.Events.Distributed;
+using Volo.Abp.EventBus.Distributed;
+using Volo.Abp.Uow;
+using Volo.Abp.Users;
+
+namespace Volo.Abp.PermissionManagement.Identity;
+
+public class UserDeletedEventHandler :
+    IDistributedEventHandler<EntityDeletedEto<UserEto>>,
+    ITransientDependency
+{
+    protected IPermissionManager PermissionManager { get; }
+
+    public UserDeletedEventHandler(IPermissionManager permissionManager)
+    {
+        PermissionManager = permissionManager;
+    }
+
+    [UnitOfWork]
+    public virtual async Task HandleEventAsync(EntityDeletedEto<UserEto> eventData)
+    {
+        await PermissionManager.DeleteAsync(UserPermissionValueProvider.ProviderName, eventData.Entity.Id.ToString());
+    }
+}

modules/identity/test/Volo.Abp.Identity.Application.Tests/Volo/Abp/Identity/IdentityRoleAppService_Tests.cs

@@ -4,6 +4,9 @@ using System.Threading.Tasks;
 using Xunit;
 using Shouldly;
 using Volo.Abp.Application.Dtos;
+using Volo.Abp.Authorization.Permissions;
+using Volo.Abp.PermissionManagement;
+using Volo.Abp.PermissionManagement.Identity;
 
 namespace Volo.Abp.Identity;
 
@@ -11,11 +14,14 @@ public class IdentityRoleAppService_Tests : AbpIdentityApplicationTestBase
 {
     private readonly IIdentityRoleAppService _roleAppService;
     private readonly IIdentityRoleRepository _roleRepository;
-
+    private readonly IPermissionManager _permissionManager;
+    private readonly RolePermissionManagementProvider _rolePermissionManagementProvider;
     public IdentityRoleAppService_Tests()
     {
         _roleAppService = GetRequiredService<IIdentityRoleAppService>();
         _roleRepository = GetRequiredService<IIdentityRoleRepository>();
+        _permissionManager = GetRequiredService<IPermissionManager>();
+        _rolePermissionManagementProvider = GetRequiredService<RolePermissionManagementProvider>();
     }
 
     [Fact]
@@ -125,6 +131,20 @@ public class IdentityRoleAppService_Tests : AbpIdentityApplicationTestBase
         (await FindRoleAsync("moderator")).ShouldBeNull();
     }
 
+
+    [Fact]
+    public async Task Role_Permissions_Should_Deleted_If_Role_Deleted()
+    {
+        var moderator = await GetRoleAsync("moderator");
+
+        (await _rolePermissionManagementProvider.CheckAsync(IdentityPermissions.Users.Create, RolePermissionValueProvider.ProviderName, moderator.Name)).IsGranted.ShouldBeFalse();
+        await _permissionManager.SetForRoleAsync(moderator.Name, IdentityPermissions.Users.Create, true);
+        (await _rolePermissionManagementProvider.CheckAsync(IdentityPermissions.Users.Create, RolePermissionValueProvider.ProviderName, moderator.Name)).IsGranted.ShouldBeTrue();
+
+        await _roleAppService.DeleteAsync(moderator.Id);
+        (await _rolePermissionManagementProvider.CheckAsync(IdentityPermissions.Users.Create, RolePermissionValueProvider.ProviderName, moderator.Name)).IsGranted.ShouldBeFalse();
+    }
+
     private async Task<IdentityRole> GetRoleAsync(string roleName)
     {
         return (await _roleRepository.GetListAsync()).First(u => u.Name == roleName);

modules/identity/test/Volo.Abp.Identity.Application.Tests/Volo/Abp/Identity/IdentityUserAppService_Tests.cs

@@ -1,7 +1,10 @@
 using System;
 using System.Threading.Tasks;
 using Shouldly;
+using Volo.Abp.Authorization.Permissions;
 using Volo.Abp.Data;
+using Volo.Abp.PermissionManagement;
+using Volo.Abp.PermissionManagement.Identity;
 using Xunit;
 
 namespace Volo.Abp.Identity;
@@ -10,12 +13,16 @@ public class IdentityUserAppService_Tests : AbpIdentityApplicationTestBase
 {
     private readonly IIdentityUserAppService _userAppService;
     private readonly IIdentityUserRepository _userRepository;
+    private readonly IPermissionManager _permissionManager;
+    private readonly UserPermissionManagementProvider _userPermissionManagementProvider;
     private readonly IdentityTestData _testData;
 
     public IdentityUserAppService_Tests()
     {
         _userAppService = GetRequiredService<IIdentityUserAppService>();
         _userRepository = GetRequiredService<IIdentityUserRepository>();
+        _permissionManager = GetRequiredService<IPermissionManager>();
+        _userPermissionManagementProvider = GetRequiredService<UserPermissionManagementProvider>();
         _testData = GetRequiredService<IdentityTestData>();
     }
 
@@ -174,6 +181,19 @@ public class IdentityUserAppService_Tests : AbpIdentityApplicationTestBase
         FindUser("john.nash").ShouldBeNull();
     }
 
+    [Fact]
+    public async Task User_Permissions_Should_Deleted_If_User_Deleted()
+    {
+        var johnNash = GetUser("john.nash");
+
+        (await _userPermissionManagementProvider.CheckAsync(IdentityPermissions.Users.Create, UserPermissionValueProvider.ProviderName, johnNash.Id.ToString())).IsGranted.ShouldBeFalse();
+        await _permissionManager.SetForUserAsync(johnNash.Id, IdentityPermissions.Users.Create, true);
+        (await _userPermissionManagementProvider.CheckAsync(IdentityPermissions.Users.Create, UserPermissionValueProvider.ProviderName, johnNash.Id.ToString())).IsGranted.ShouldBeTrue();
+
+        await _userAppService.DeleteAsync(johnNash.Id);
+        (await _userPermissionManagementProvider.CheckAsync(IdentityPermissions.Users.Create, UserPermissionValueProvider.ProviderName, johnNash.Id.ToString())).IsGranted.ShouldBeFalse();
+    }
+
     [Fact]
     public async Task GetRolesAsync()
     {

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

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Security.Claims;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Identity;
 using Microsoft.Extensions.DependencyInjection;
@@ -26,8 +27,10 @@ public class IdentityUserManager_Tests : AbpIdentityDomainTestBase
     private readonly IUnitOfWorkManager _unitOfWorkManager;
     private readonly IdentityTestData _testData;
     private readonly ICurrentTenant _currentTenant;
-    protected IOptions<IdentityOptions> _identityOptions { get; }
+    private readonly IOptions<IdentityOptions> _identityOptions;
-    protected IDistributedEventBus DistributedEventBus { get; set; }
+    private readonly IdentityLinkUserManager _identityLinkUserManager;
+
+    private IDistributedEventBus _distributedEventBus { get; set; }
 
     public IdentityUserManager_Tests()
     {
@@ -40,12 +43,13 @@ public class IdentityUserManager_Tests : AbpIdentityDomainTestBase
         _unitOfWorkManager = GetRequiredService<IUnitOfWorkManager>();
         _currentTenant = GetRequiredService<ICurrentTenant>();
         _identityOptions = GetRequiredService<IOptions<IdentityOptions>>();
+        _identityLinkUserManager = GetRequiredService<IdentityLinkUserManager>();
     }
 
     protected override void AfterAddApplication(IServiceCollection services)
     {
-        DistributedEventBus = Substitute.For<IDistributedEventBus>();
+        _distributedEventBus = Substitute.For<IDistributedEventBus>();
-        services.Replace(ServiceDescriptor.Singleton(DistributedEventBus));
+        services.Replace(ServiceDescriptor.Singleton(_distributedEventBus));
     }
 
     [Fact]
@@ -270,7 +274,7 @@ public class IdentityUserManager_Tests : AbpIdentityDomainTestBase
 
         (await _identityUserManager.CreateAsync(user)).CheckErrors();
 
-        await DistributedEventBus.DidNotReceive()
+        await _distributedEventBus.DidNotReceive()
             .PublishAsync(Arg.Any<IdentityUserUserNameChangedEto>(), Arg.Any<bool>(), Arg.Any<bool>());
 
         var newUser = await _identityUserManager.FindByIdAsync(user.Id.ToString());
@@ -280,16 +284,16 @@ public class IdentityUserManager_Tests : AbpIdentityDomainTestBase
         {
             var oldUsername = newUser.UserName;
             await _identityUserManager.SetUserNameAsync(newUser, "newUserName");
-            await DistributedEventBus.Received()
+            await _distributedEventBus.Received()
                 .PublishAsync(
                     Arg.Is<IdentityUserUserNameChangedEto>(x =>
                         x.Id == newUser.Id && x.TenantId == newUser.TenantId && x.OldUserName == oldUsername && x.UserName == "newUserName"),
                     Arg.Any<bool>(), Arg.Any<bool>());
         }
 
-        DistributedEventBus.ClearReceivedCalls();
+        _distributedEventBus.ClearReceivedCalls();
         await _identityUserManager.SetUserNameAsync(newUser, newUser.UserName);
-        await DistributedEventBus.DidNotReceive()
+        await _distributedEventBus.DidNotReceive()
             .PublishAsync(Arg.Any<IdentityUserUserNameChangedEto>(), Arg.Any<bool>(), Arg.Any<bool>());
     }
 
@@ -300,7 +304,7 @@ public class IdentityUserManager_Tests : AbpIdentityDomainTestBase
 
         (await _identityUserManager.CreateAsync(user)).CheckErrors();
 
-        await DistributedEventBus.DidNotReceive()
+        await _distributedEventBus.DidNotReceive()
             .PublishAsync(Arg.Any<IdentityUserEmailChangedEto>(), Arg.Any<bool>(), Arg.Any<bool>());
 
         var newUser = await _identityUserManager.FindByIdAsync(user.Id.ToString());
@@ -310,19 +314,70 @@ public class IdentityUserManager_Tests : AbpIdentityDomainTestBase
         {
             var oldEmail = newUser.Email;
             await _identityUserManager.SetEmailAsync(newUser, "newEmail@abp.io");
-            await DistributedEventBus.Received()
+            await _distributedEventBus.Received()
                 .PublishAsync(
                     Arg.Is<IdentityUserEmailChangedEto>(x =>
                         x.Id == newUser.Id && x.TenantId == newUser.TenantId && x.OldEmail == oldEmail && x.Email == "newEmail@abp.io"),
                     Arg.Any<bool>(), Arg.Any<bool>());
         }
 
-        DistributedEventBus.ClearReceivedCalls();
+        _distributedEventBus.ClearReceivedCalls();
         await _identityUserManager.SetEmailAsync(newUser, newUser.Email);
-        await DistributedEventBus.DidNotReceive()
+        await _distributedEventBus.DidNotReceive()
             .PublishAsync(Arg.Any<IdentityUserEmailChangedEto>(), Arg.Any<bool>(), Arg.Any<bool>());
     }
 
+    [Fact]
+    public async Task DeleteAsync()
+    {
+        await CreateRandomDefaultRoleAsync();
+        var user = CreateRandomUser();
+        (await _identityUserManager.CreateAsync(user)).CheckErrors();
+
+        var user2 = CreateRandomUser();
+        (await _identityUserManager.CreateAsync(user2)).CheckErrors();
+
+        using (var uow = _unitOfWorkManager.Begin())
+        {
+            user = await _identityUserManager.FindByIdAsync(user.Id.ToString());
+            user.ShouldNotBeNull();
+
+            await _identityUserManager.AddClaimAsync(user, new Claim("test", "test"));
+            await _identityUserManager.AddLoginAsync(user, new UserLoginInfo("test", "test", "test"));
+            await _identityUserManager.AddDefaultRolesAsync(user);
+            user.SetToken("test", "test", "test");
+            var ou = await _organizationUnitRepository.GetAsync(_lookupNormalizer.NormalizeName("OU11"));
+            await _identityUserManager.AddToOrganizationUnitAsync(user, ou);
+            await _identityLinkUserManager.LinkAsync(new IdentityLinkUserInfo(user.Id), new IdentityLinkUserInfo(user2.Id));
+
+            await uow.CompleteAsync();
+        }
+
+        using (var uow = _unitOfWorkManager.Begin())
+        {
+            user = await _identityUserManager.FindByIdAsync(user.Id.ToString());
+            user.ShouldNotBeNull();
+
+            user.Claims.Count.ShouldBeGreaterThan(0);
+            user.Logins.Count.ShouldBeGreaterThan(0);
+            user.Roles.Count.ShouldBeGreaterThan(0);
+            user.Tokens.Count.ShouldBeGreaterThan(0);
+            user.OrganizationUnits.Count.ShouldBeGreaterThan(0);
+            (await _identityLinkUserManager.IsLinkedAsync(new IdentityLinkUserInfo(user.Id), new IdentityLinkUserInfo(user2.Id))).ShouldBeTrue();
+
+            await _identityUserManager.DeleteAsync(user);
+
+            user.Claims.Count.ShouldBe(0);
+            user.Logins.Count.ShouldBe(0);
+            user.Roles.Count.ShouldBe(0);
+            user.Tokens.Count.ShouldBe(0);
+            user.OrganizationUnits.Count.ShouldBe(0);
+            (await _identityLinkUserManager.IsLinkedAsync(new IdentityLinkUserInfo(user.Id), new IdentityLinkUserInfo(user2.Id))).ShouldBeFalse();
+
+            await uow.CompleteAsync();
+        }
+    }
+
     private async Task CreateRandomDefaultRoleAsync()
     {
         await _identityRoleRepository.InsertAsync(

modules/setting-management/src/Volo.Abp.SettingManagement.Application/Volo.Abp.SettingManagement.Application.csproj

@@ -13,6 +13,7 @@
         <ProjectReference Include="..\..\..\..\framework\src\Volo.Abp.Ddd.Application\Volo.Abp.Ddd.Application.csproj" />
         <ProjectReference Include="..\Volo.Abp.SettingManagement.Application.Contracts\Volo.Abp.SettingManagement.Application.Contracts.csproj" />
         <ProjectReference Include="..\Volo.Abp.SettingManagement.Domain\Volo.Abp.SettingManagement.Domain.csproj" />
+        <ProjectReference Include="..\..\..\users\src\Volo.Abp.Users.Abstractions\Volo.Abp.Users.Abstractions.csproj" />
     </ItemGroup>
 
 </Project>

modules/setting-management/src/Volo.Abp.SettingManagement.Application/Volo/Abp/SettingManagement/AbpSettingManagementApplicationModule.cs

@@ -2,6 +2,7 @@
 using Volo.Abp.Emailing;
 using Volo.Abp.Modularity;
 using Volo.Abp.Timing;
+using Volo.Abp.Users;
 
 namespace Volo.Abp.SettingManagement;
 
@@ -10,7 +11,8 @@ namespace Volo.Abp.SettingManagement;
     typeof(AbpSettingManagementDomainModule),
     typeof(AbpSettingManagementApplicationContractsModule),
     typeof(AbpEmailingModule),
-    typeof(AbpTimingModule)
+    typeof(AbpTimingModule),
+    typeof(AbpUsersAbstractionModule)
 )]
 public class AbpSettingManagementApplicationModule : AbpModule
 {

modules/setting-management/src/Volo.Abp.SettingManagement.Application/Volo/Abp/SettingManagement/UserDeletedEventHandler.cs

@@ -0,0 +1,27 @@
+using System.Threading.Tasks;
+using Volo.Abp.DependencyInjection;
+using Volo.Abp.Domain.Entities.Events.Distributed;
+using Volo.Abp.EventBus.Distributed;
+using Volo.Abp.Settings;
+using Volo.Abp.Uow;
+using Volo.Abp.Users;
+
+namespace Volo.Abp.SettingManagement;
+
+public class UserDeletedEventHandler :
+    IDistributedEventHandler<EntityDeletedEto<UserEto>>,
+    ITransientDependency
+{
+    protected ISettingManager SettingManager { get; }
+
+    public UserDeletedEventHandler(ISettingManager settingManager)
+    {
+        SettingManager = settingManager;
+    }
+
+    [UnitOfWork]
+    public virtual async Task HandleEventAsync(EntityDeletedEto<UserEto> eventData)
+    {
+        await SettingManager.DeleteAsync(UserSettingValueProvider.ProviderName, eventData.Entity.Id.ToString());
+    }
+}

modules/setting-management/src/Volo.Abp.SettingManagement.Domain/Volo/Abp/SettingManagement/ISettingManager.cs

@@ -12,4 +12,6 @@ public interface ISettingManager
     Task<List<SettingValue>> GetAllAsync([NotNull] string providerName, [CanBeNull] string providerKey, bool fallback = true);
 
     Task SetAsync([NotNull] string name, [CanBeNull] string value, [NotNull] string providerName, [CanBeNull] string providerKey, bool forceToSet = false);
+
+    Task DeleteAsync(string providerName, string providerKey);
 }

modules/setting-management/src/Volo.Abp.SettingManagement.Domain/Volo/Abp/SettingManagement/SettingManager.cs

@@ -13,6 +13,7 @@ public class SettingManager : ISettingManager, ISingletonDependency
 {
     protected ISettingDefinitionManager SettingDefinitionManager { get; }
     protected ISettingEncryptionService SettingEncryptionService { get; }
+    protected ISettingManagementStore SettingManagementStore { get; }
     protected List<ISettingManagementProvider> Providers => _lazyProviders.Value;
     protected SettingManagementOptions Options { get; }
     private readonly Lazy<List<ISettingManagementProvider>> _lazyProviders;
@@ -21,10 +22,12 @@ public class SettingManager : ISettingManager, ISingletonDependency
         IOptions<SettingManagementOptions> options,
         IServiceProvider serviceProvider,
         ISettingDefinitionManager settingDefinitionManager,
-        ISettingEncryptionService settingEncryptionService)
+        ISettingEncryptionService settingEncryptionService,
+        ISettingManagementStore settingManagementStore)
     {
         SettingDefinitionManager = settingDefinitionManager;
         SettingEncryptionService = settingEncryptionService;
+        SettingManagementStore = settingManagementStore;
         Options = options.Value;
 
         //TODO: Instead, use IServiceScopeFactory and create a scope..?
@@ -160,6 +163,15 @@ public class SettingManager : ISettingManager, ISingletonDependency
         }
     }
 
+    public virtual async Task DeleteAsync(string providerName, string providerKey)
+    {
+        var settings = await SettingManagementStore.GetListAsync(providerName, providerKey);
+        foreach (var setting in settings)
+        {
+            await SettingManagementStore.DeleteAsync(setting.Name, providerName, providerKey);
+        }
+    }
+
     protected virtual async Task<string> GetOrNullInternalAsync(string name, string providerName, string providerKey, bool fallback = true)
     {
         var setting = await SettingDefinitionManager.GetAsync(name);

modules/setting-management/test/Volo.Abp.SettingManagement.Tests/Volo/Abp/SettingManagement/SettingManager_User_Tests.cs

@@ -186,4 +186,16 @@ public class SettingManager_User_Tests : SettingsTestBase
         (await _settingManager.GetOrNullForUserAsync("MySettingWithoutInherit", _testData.User2Id)).ShouldBeNull(); //Does not inherit!
         (await _settingManager.GetOrNullGlobalAsync("MySettingWithoutInherit")).ShouldBe("default-store-value");
     }
+
+    [Fact]
+    public async Task DeleteAsync()
+    {
+        (await _settingManager.GetOrNullForUserAsync("MySetting2", _testData.User1Id)).ShouldBe("user1-store-value");
+        (await _settingManager.GetOrNullForUserAsync("MySettingWithoutInherit", _testData.User1Id)).ShouldBe("user1-store-value");
+
+        await _settingManager.DeleteAsync(UserSettingValueProvider.ProviderName, _testData.User1Id.ToString());
+
+        (await _settingManager.GetOrNullForUserAsync("MySetting2", _testData.User1Id)).ShouldNotBe("user1-store-value");
+        (await _settingManager.GetOrNullForUserAsync("MySettingWithoutInherit", _testData.User1Id)).ShouldNotBe("user1-store-value");
+    }
 }