Async user service.

backend/src/Squidex.Domain.Apps.Entities/History/NotifoService.cs

@@ -5,6 +5,7 @@
 //  All rights reserved. Licensed under the MIT license.
 // ==========================================================================
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
@@ -19,7 +20,6 @@ using Squidex.Domain.Apps.Events.Contents;
 using Squidex.Domain.Users;
 using Squidex.Infrastructure;
 using Squidex.Infrastructure.EventSourcing;
-using Squidex.Infrastructure.Tasks;
 using Squidex.Shared.Identity;
 using Squidex.Shared.Users;
 
@@ -63,9 +63,20 @@ namespace Squidex.Domain.Apps.Entities.History
             }
         }
 
-        public void OnUserUpdated(IUser user)
+        public async Task OnUserCreatedAsync(IUser user)
         {
-            UpsertUserAsync(user).Forget();
+            if (!string.IsNullOrWhiteSpace(user.Email))
+            {
+                await UpsertUserAsync(user);
+            }
+        }
+
+        public async Task OnUserUpdatedAsync(IUser user, IUser previous)
+        {
+            if (!string.Equals(user.Email, previous?.Email, StringComparison.OrdinalIgnoreCase))
+            {
+                await UpsertUserAsync(user);
+            }
         }
 
         private async Task UpsertUserAsync(IUser user)

backend/src/Squidex.Domain.Users/DefaultUserService.cs

@@ -217,14 +217,14 @@ namespace Squidex.Domain.Users
 
             foreach (var @events in userEvents)
             {
-                @events.OnUserRegistered(resolved);
+                await @events.OnUserRegisteredAsync(resolved);
             }
 
             if (HasConsentGiven(values, null!))
             {
                 foreach (var @events in userEvents)
                 {
-                    @events.OnConsentGiven(resolved);
+                    await @events.OnConsentGivenAsync(resolved);
                 }
             }
 
@@ -281,14 +281,14 @@ namespace Squidex.Domain.Users
             {
                 foreach (var @events in userEvents)
                 {
-                    @events.OnUserUpdated(resolved);
+                    await @events.OnUserUpdatedAsync(resolved, oldUser);
                 }
 
                 if (HasConsentGiven(values, oldUser))
                 {
                     foreach (var @events in userEvents)
                     {
-                        @events.OnConsentGiven(resolved);
+                        await @events.OnConsentGivenAsync(resolved);
                     }
                 }
             }
@@ -336,7 +336,7 @@ namespace Squidex.Domain.Users
 
             foreach (var @events in userEvents)
             {
-                @events.OnUserDeleted(resolved);
+                await @events.OnUserDeletedAsync(resolved);
             }
         }
 

backend/src/Squidex.Domain.Users/IUserEvents.cs

@@ -5,26 +5,31 @@
 //  All rights reserved. Licensed under the MIT license.
 // ==========================================================================
 
+using System.Threading.Tasks;
 using Squidex.Shared.Users;
 
 namespace Squidex.Domain.Users
 {
     public interface IUserEvents
     {
-        void OnUserRegistered(IUser user)
+        Task OnUserRegisteredAsync(IUser user)
         {
+            return Task.CompletedTask;
         }
 
-        void OnUserUpdated(IUser user)
+        Task OnUserUpdatedAsync(IUser user, IUser previous)
         {
+            return Task.CompletedTask;
         }
 
-        void OnUserDeleted(IUser user)
+        Task OnUserDeletedAsync(IUser user)
         {
+            return Task.CompletedTask;
         }
 
-        void OnConsentGiven(IUser user)
+        Task OnConsentGivenAsync(IUser user)
         {
+            return Task.CompletedTask;
         }
     }
 }

backend/tests/Squidex.Domain.Users.Tests/DefaultUserServiceTests.cs

@@ -179,10 +179,10 @@ namespace Squidex.Domain.Users
 
             await sut.CreateAsync(values.Email, values);
 
-            A.CallTo(() => userEvents.OnUserRegistered(A<IUser>.That.Matches(x => x.Identity == identity)))
+            A.CallTo(() => userEvents.OnUserRegisteredAsync(A<IUser>.That.Matches(x => x.Identity == identity)))
                 .MustHaveHappened();
 
-            A.CallTo(() => userEvents.OnConsentGiven(A<IUser>.That.Matches(x => x.Identity == identity)))
+            A.CallTo(() => userEvents.OnConsentGivenAsync(A<IUser>.That.Matches(x => x.Identity == identity)))
                 .MustNotHaveHappened();
 
             A.CallTo(() => userManager.AddClaimsAsync(identity, HasClaim(SquidexClaimTypes.Permissions)))
@@ -209,7 +209,7 @@ namespace Squidex.Domain.Users
 
             await sut.CreateAsync(identity.Email, values);
 
-            A.CallTo(() => userEvents.OnConsentGiven(A<IUser>.That.Matches(x => x.Identity == identity)))
+            A.CallTo(() => userEvents.OnConsentGivenAsync(A<IUser>.That.Matches(x => x.Identity == identity)))
                 .MustHaveHappened();
         }
 
@@ -307,7 +307,7 @@ namespace Squidex.Domain.Users
 
             await sut.UpdateAsync(identity.Id, update, true);
 
-            A.CallTo(() => userEvents.OnUserUpdated(A<IUser>.That.Matches(x => x.Identity == identity)))
+            A.CallTo(() => userEvents.OnUserUpdatedAsync(A<IUser>.That.Matches(x => x.Identity == identity), A<IUser>._))
                 .MustNotHaveHappened();
         }
 
@@ -320,7 +320,7 @@ namespace Squidex.Domain.Users
 
             await sut.UpdateAsync(identity.Id, update);
 
-            A.CallTo(() => userEvents.OnUserUpdated(A<IUser>.That.Matches(x => x.Identity == identity)))
+            A.CallTo(() => userEvents.OnUserUpdatedAsync(A<IUser>.That.Matches(x => x.Identity == identity), A<IUser>._))
                 .MustHaveHappened();
         }
 
@@ -380,7 +380,7 @@ namespace Squidex.Domain.Users
             A.CallTo<Task<IdentityResult>>(() => userManager.AddClaimsAsync(identity, HasClaim(SquidexClaimTypes.Consent)))
                 .MustHaveHappened();
 
-            A.CallTo(() => userEvents.OnConsentGiven(A<IUser>.That.Matches(x => x.Identity == identity)))
+            A.CallTo(() => userEvents.OnConsentGivenAsync(A<IUser>.That.Matches(x => x.Identity == identity)))
                 .MustHaveHappened();
         }
 
@@ -399,7 +399,7 @@ namespace Squidex.Domain.Users
             A.CallTo<Task<IdentityResult>>(() => userManager.AddClaimsAsync(identity, HasClaim(SquidexClaimTypes.ConsentForEmails)))
                 .MustHaveHappened();
 
-            A.CallTo(() => userEvents.OnConsentGiven(A<IUser>.That.Matches(x => x.Identity == identity)))
+            A.CallTo(() => userEvents.OnConsentGivenAsync(A<IUser>.That.Matches(x => x.Identity == identity)))
                 .MustHaveHappened();
         }
 
@@ -535,7 +535,7 @@ namespace Squidex.Domain.Users
 
             await Assert.ThrowsAsync<DomainObjectNotFoundException>(() => sut.DeleteAsync(identity.Id));
 
-            A.CallTo(() => userEvents.OnUserDeleted(A<IUser>._))
+            A.CallTo(() => userEvents.OnUserDeletedAsync(A<IUser>._))
                 .MustNotHaveHappened();
         }
 
@@ -549,7 +549,7 @@ namespace Squidex.Domain.Users
             A.CallTo(() => userManager.DeleteAsync(identity))
                 .MustHaveHappened();
 
-            A.CallTo(() => userEvents.OnUserDeleted(A<IUser>.That.Matches(x => x.Identity == identity)))
+            A.CallTo(() => userEvents.OnUserDeletedAsync(A<IUser>.That.Matches(x => x.Identity == identity)))
                 .MustHaveHappened();
         }