Merge pull request #17990 from abpframework/salihozkara/emailChangedEvent

Add email/username changed event

modules/identity/src/Volo.Abp.Identity.Domain.Shared/Volo/Abp/Identity/IdentityUserEmailChangedEto.cs

@@ -0,0 +1,16 @@
+using System;
+using Volo.Abp.MultiTenancy;
+
+namespace Volo.Abp.Identity;
+
+[Serializable]
+public class IdentityUserEmailChangedEto : IMultiTenant 
+{
+    public Guid Id { get; set; }
+
+    public Guid? TenantId { get; set; }
+
+    public string Email { get; set; }
+
+    public string OldEmail { get; set; }
+}

modules/identity/src/Volo.Abp.Identity.Domain.Shared/Volo/Abp/Identity/IdentityUserUserNameChangedEto.cs

@@ -0,0 +1,16 @@
+using System;
+using Volo.Abp.MultiTenancy;
+
+namespace Volo.Abp.Identity;
+
+[Serializable]
+public class IdentityUserUserNameChangedEto : IMultiTenant
+{
+    public Guid Id { get; set; }
+
+    public Guid? TenantId { get; set; }
+
+    public string UserName { get; set; }
+
+    public string OldUserName { get; set; }
+}

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

@@ -10,6 +10,7 @@ using Microsoft.Extensions.Options;
 using Volo.Abp.Domain.Entities;
 using Volo.Abp.Domain.Repositories;
 using Volo.Abp.Domain.Services;
+using Volo.Abp.EventBus.Distributed;
 using Volo.Abp.Identity.Settings;
 using Volo.Abp.Settings;
 using Volo.Abp.Threading;
@@ -25,6 +26,7 @@ public class IdentityUserManager : UserManager<IdentityUser>, IDomainService
     protected IOrganizationUnitRepository OrganizationUnitRepository { get; }
     protected ISettingProvider SettingProvider { get; }
     protected ICancellationTokenProvider CancellationTokenProvider { get; }
+    protected IDistributedEventBus DistributedEventBus { get; }
 
     protected override CancellationToken CancellationToken => CancellationTokenProvider.Token;
 
@@ -42,7 +44,8 @@ public class IdentityUserManager : UserManager<IdentityUser>, IDomainService
         ILogger<IdentityUserManager> logger,
         ICancellationTokenProvider cancellationTokenProvider,
         IOrganizationUnitRepository organizationUnitRepository,
-        ISettingProvider settingProvider)
+        ISettingProvider settingProvider,
+        IDistributedEventBus distributedEventBus)
         : base(
             store,
             optionsAccessor,
@@ -56,6 +59,7 @@ public class IdentityUserManager : UserManager<IdentityUser>, IDomainService
     {
         OrganizationUnitRepository = organizationUnitRepository;
         SettingProvider = settingProvider;
+        DistributedEventBus = distributedEventBus;
         RoleRepository = roleRepository;
         UserRepository = userRepository;
         CancellationTokenProvider = cancellationTokenProvider;
@@ -285,4 +289,50 @@ public class IdentityUserManager : UserManager<IdentityUser>, IDomainService
 
         await identityUserStore.SetTokenAsync(user, await identityUserStore.GetInternalLoginProviderAsync(), await identityUserStore.GetRecoveryCodeTokenNameAsync(), string.Empty, CancellationToken);
     }
+
+    public async override Task<IdentityResult> SetEmailAsync(IdentityUser user, string email)
+    {
+        var oldMail = user.Email;
+
+        var result = await base.SetEmailAsync(user, email);
+
+        result.CheckErrors();
+
+        if (!string.IsNullOrEmpty(oldMail) && !oldMail.Equals(email, StringComparison.OrdinalIgnoreCase))
+        {
+            await DistributedEventBus.PublishAsync(
+                new IdentityUserEmailChangedEto
+                {
+                    Id = user.Id,
+                    TenantId = user.TenantId,
+                    Email = email,
+                    OldEmail = oldMail
+                });
+        }
+
+        return result;
+    }
+
+    public async override Task<IdentityResult> SetUserNameAsync(IdentityUser user, string userName)
+    {
+        var oldUserName = user.UserName;
+
+        var result = await base.SetUserNameAsync(user, userName);
+
+        result.CheckErrors();
+
+        if (!string.IsNullOrEmpty(oldUserName) && oldUserName != userName)
+        {
+            await DistributedEventBus.PublishAsync(
+                new IdentityUserUserNameChangedEto
+                {
+                    Id = user.Id,
+                    TenantId = user.TenantId,
+                    UserName = userName,
+                    OldUserName = oldUserName
+                });
+        }
+
+        return result;
+    }
 }

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

@@ -3,9 +3,14 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Identity;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Options;
+using NSubstitute;
 using Shouldly;
+using Volo.Abp.EventBus.Distributed;
 using Volo.Abp.Identity.Settings;
+using Volo.Abp.MultiTenancy;
 using Volo.Abp.Uow;
 using Xunit;
 
@@ -20,7 +25,9 @@ public class IdentityUserManager_Tests : AbpIdentityDomainTestBase
     private readonly ILookupNormalizer _lookupNormalizer;
     private readonly IUnitOfWorkManager _unitOfWorkManager;
     private readonly IdentityTestData _testData;
+    private readonly ICurrentTenant _currentTenant;
     protected IOptions<IdentityOptions> _identityOptions { get; }
+    protected IDistributedEventBus DistributedEventBus { get; set; }
 
     public IdentityUserManager_Tests()
     {
@@ -31,9 +38,16 @@ public class IdentityUserManager_Tests : AbpIdentityDomainTestBase
         _lookupNormalizer = GetRequiredService<ILookupNormalizer>();
         _testData = GetRequiredService<IdentityTestData>();
         _unitOfWorkManager = GetRequiredService<IUnitOfWorkManager>();
+        _currentTenant = GetRequiredService<ICurrentTenant>();
         _identityOptions = GetRequiredService<IOptions<IdentityOptions>>();
     }
 
+    protected override void AfterAddApplication(IServiceCollection services)
+    {
+        DistributedEventBus = Substitute.For<IDistributedEventBus>();
+        services.Replace(ServiceDescriptor.Singleton(DistributedEventBus));
+    }
+
     [Fact]
     public async Task GetByIdAsync()
     {
@@ -249,6 +263,66 @@ public class IdentityUserManager_Tests : AbpIdentityDomainTestBase
         (await _identityUserManager.ShouldPeriodicallyChangePasswordAsync(user)).ShouldBeTrue();
     }
 
+    [Fact]
+    public async Task IdentityUserUserNameChangedEto_Test()
+    {
+        var user = CreateRandomUser();
+
+        (await _identityUserManager.CreateAsync(user)).CheckErrors();
+
+        await DistributedEventBus.DidNotReceive()
+            .PublishAsync(Arg.Any<IdentityUserUserNameChangedEto>(), Arg.Any<bool>(), Arg.Any<bool>());
+
+        var newUser = await _identityUserManager.FindByIdAsync(user.Id.ToString());
+        newUser.ShouldNotBeNull();
+
+        using (_currentTenant.Change(Guid.NewGuid()))
+        {
+            var oldUsername = newUser.UserName;
+            await _identityUserManager.SetUserNameAsync(newUser, "newUserName");
+            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();
+        await _identityUserManager.SetUserNameAsync(newUser, newUser.UserName);
+        await DistributedEventBus.DidNotReceive()
+            .PublishAsync(Arg.Any<IdentityUserUserNameChangedEto>(), Arg.Any<bool>(), Arg.Any<bool>());
+    }
+
+    [Fact]
+    public async Task IdentityUserEmailChangedEto_Test()
+    {
+        var user = CreateRandomUser();
+
+        (await _identityUserManager.CreateAsync(user)).CheckErrors();
+
+        await DistributedEventBus.DidNotReceive()
+            .PublishAsync(Arg.Any<IdentityUserEmailChangedEto>(), Arg.Any<bool>(), Arg.Any<bool>());
+
+        var newUser = await _identityUserManager.FindByIdAsync(user.Id.ToString());
+        newUser.ShouldNotBeNull();
+
+        using (_currentTenant.Change(Guid.NewGuid()))
+        {
+            var oldEmail = newUser.Email;
+            await _identityUserManager.SetEmailAsync(newUser, "newEmail@abp.io");
+            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();
+        await _identityUserManager.SetEmailAsync(newUser, newUser.Email);
+        await DistributedEventBus.DidNotReceive()
+            .PublishAsync(Arg.Any<IdentityUserEmailChangedEto>(), Arg.Any<bool>(), Arg.Any<bool>());
+    }
+
     private async Task CreateRandomDefaultRoleAsync()
     {
         await _identityRoleRepository.InsertAsync(