Rule fixes.

backend/src/Squidex.Domain.Apps.Entities/Rules/IRuleEnqueuer.cs

@@ -14,6 +14,6 @@ namespace Squidex.Domain.Apps.Entities.Rules
 {
     public interface IRuleEnqueuer
     {
-        Task Enqueue(Rule rule, Guid ruleId, Envelope<IEvent> @event);
+        Task EnqueueAsync(Rule rule, Guid ruleId, Envelope<IEvent> @event);
     }
 }

backend/src/Squidex.Domain.Apps.Entities/Rules/RuleDomainObject.cs

@@ -100,7 +100,7 @@ namespace Squidex.Domain.Apps.Entities.Rules
 
             var @event = SimpleMapper.Map(command, new RuleManuallyTriggered { RuleId = Snapshot.Id, AppId = Snapshot.AppId });
 
-            await ruleEnqueuer.Enqueue(Snapshot.RuleDef, Snapshot.Id, Envelope.Create(@event));
+            await ruleEnqueuer.EnqueueAsync(Snapshot.RuleDef, Snapshot.Id, Envelope.Create(@event));
 
             return null;
         }

backend/src/Squidex.Domain.Apps.Entities/Rules/RuleEnqueuer.cs

@@ -50,46 +50,46 @@ namespace Squidex.Domain.Apps.Entities.Rules
             this.localCache = localCache;
         }
 
-        public async Task Enqueue(Rule rule, Guid ruleId, Envelope<IEvent> @event)
+        public async Task EnqueueAsync(Rule rule, Guid ruleId, Envelope<IEvent> @event)
         {
             Guard.NotNull(rule, nameof(rule));
             Guard.NotNull(@event, nameof(@event));
 
-            using (localCache.StartContext())
-            {
-                var jobs = await ruleService.CreateJobsAsync(rule, ruleId, @event);
+            var jobs = await ruleService.CreateJobsAsync(rule, ruleId, @event);
 
-                foreach (var (job, ex) in jobs)
+            foreach (var (job, ex) in jobs)
+            {
+                if (ex != null)
                 {
-                    if (ex != null)
-                    {
-                        await ruleEventRepository.EnqueueAsync(job, null);
+                    await ruleEventRepository.EnqueueAsync(job, null);
 
-                        await ruleEventRepository.UpdateAsync(job, new RuleJobUpdate
-                        {
-                            JobResult = RuleJobResult.Failed,
-                            ExecutionResult = RuleResult.Failed,
-                            ExecutionDump = ex.ToString(),
-                            Finished = job.Created
-                        });
-                    }
-                    else
+                    await ruleEventRepository.UpdateAsync(job, new RuleJobUpdate
                     {
-                        await ruleEventRepository.EnqueueAsync(job, job.Created);
-                    }
+                        JobResult = RuleJobResult.Failed,
+                        ExecutionResult = RuleResult.Failed,
+                        ExecutionDump = ex.ToString(),
+                        Finished = job.Created
+                    });
+                }
+                else
+                {
+                    await ruleEventRepository.EnqueueAsync(job, job.Created);
                 }
             }
         }
 
         public async Task On(Envelope<IEvent> @event)
         {
-            if (@event.Payload is AppEvent appEvent)
+            using (localCache.StartContext())
             {
-                var rules = await GetRulesAsync(appEvent.AppId.Id);
-
-                foreach (var ruleEntity in rules)
+                if (@event.Payload is AppEvent appEvent)
                 {
-                    await Enqueue(ruleEntity.RuleDef, ruleEntity.Id, @event);
+                    var rules = await GetRulesAsync(appEvent.AppId.Id);
+
+                    foreach (var ruleEntity in rules)
+                    {
+                        await EnqueueAsync(ruleEntity.RuleDef, ruleEntity.Id, @event);
+                    }
                 }
             }
         }

backend/src/Squidex/Config/Orleans/OrleansServices.cs

@@ -59,10 +59,10 @@ namespace Squidex.Config.Orleans
                 options.HostSelf = false;
             });
 
+            builder.AddIncomingGrainCallFilter<LoggingFilter>();
             builder.AddIncomingGrainCallFilter<ExceptionWrapperFilter>();
             builder.AddIncomingGrainCallFilter<ActivationLimiterFilter>();
             builder.AddIncomingGrainCallFilter<LocalCacheFilter>();
-            builder.AddIncomingGrainCallFilter<LoggingFilter>();
             builder.AddIncomingGrainCallFilter<StateFilter>();
 
             var orleansPortSilo = config.GetOptionalValue("orleans:siloPort", 11111);

backend/tests/Squidex.Domain.Apps.Entities.Tests/Rules/RuleDomainObjectTests.cs

@@ -165,7 +165,7 @@ namespace Squidex.Domain.Apps.Entities.Rules
 
             Assert.Null(result);
 
-            A.CallTo(() => ruleEnqueuer.Enqueue(sut.Snapshot.RuleDef, sut.Id,
+            A.CallTo(() => ruleEnqueuer.EnqueueAsync(sut.Snapshot.RuleDef, sut.Id,
                 A<Envelope<IEvent>>.That.Matches(x => x.Payload is RuleManuallyTriggered)))
                 .MustHaveHappened();
         }

backend/tests/Squidex.Domain.Apps.Entities.Tests/Rules/RuleEnqueuerTests.cs

@@ -86,7 +86,7 @@ namespace Squidex.Domain.Apps.Entities.Rules
             A.CallTo(() => ruleService.CreateJobsAsync(rule.RuleDef, rule.Id, @event, true))
                 .Returns(new List<(RuleJob, Exception?)> { (job, null) });
 
-            await sut.Enqueue(rule.RuleDef, rule.Id, @event);
+            await sut.EnqueueAsync(rule.RuleDef, rule.Id, @event);
 
             A.CallTo(() => ruleEventRepository.EnqueueAsync(job, now, default))
                 .MustHaveHappened();