Cleanup

backend/src/Squidex.Domain.Apps.Core.Model/Rules/RuleJob.cs

@@ -6,7 +6,6 @@
 // ==========================================================================
 
 using System;
-using Newtonsoft.Json;
 using NodaTime;
 
 namespace Squidex.Domain.Apps.Core.Rules
@@ -32,8 +31,5 @@ namespace Squidex.Domain.Apps.Core.Rules
         public Instant Created { get; set; }
 
         public Instant Expires { get; set; }
-
-        [JsonIgnore]
-        public Exception? Exception { get; set; }
     }
 }

backend/src/Squidex.Domain.Apps.Core.Operations/HandleRules/RuleService.cs

@@ -20,6 +20,7 @@ using Squidex.Infrastructure.Json;
 using Squidex.Infrastructure.Log;
 using Squidex.Infrastructure.Reflection;
 using Squidex.Infrastructure.Tasks;
+using JobList = System.Collections.Generic.List<(Squidex.Domain.Apps.Core.Rules.RuleJob Job, System.Exception? Exception)>;
 
 namespace Squidex.Domain.Apps.Core.HandleRules
 {
@@ -67,12 +68,12 @@ namespace Squidex.Domain.Apps.Core.HandleRules
             this.log = log;
         }
 
-        public virtual async Task<List<RuleJob>> CreateJobsAsync(Rule rule, Guid ruleId, Envelope<IEvent> @event, bool ignoreStale = false)
+        public virtual async Task<JobList> CreateJobsAsync(Rule rule, Guid ruleId, Envelope<IEvent> @event, bool ignoreStale = false)
         {
             Guard.NotNull(rule, nameof(rule));
             Guard.NotNull(@event, nameof(@event));
 
-            var result = new List<RuleJob>();
+            var result = new JobList();
 
             try
             {
@@ -151,20 +152,22 @@ namespace Squidex.Domain.Apps.Core.HandleRules
 
                         try
                         {
-                            var actionData = await actionHandler.CreateJobAsync(enrichedEvent, rule.Action);
+                            var (description, data) = await actionHandler.CreateJobAsync(enrichedEvent, rule.Action);
 
-                            var json = jsonSerializer.Serialize(actionData.Data);
+                            var json = jsonSerializer.Serialize(data);
 
                             job.ActionData = json;
-                            job.Description = actionData.Description;
+                            job.ActionName = actionName;
+                            job.Description = description;
+
+                            result.Add((job, null));
                         }
                         catch (Exception ex)
                         {
                             job.Description = "Failed to create job";
-                            job.Exception = ex;
-                        }
 
-                        result.Add(job);
+                            result.Add((job, ex));
+                        }
                     }
                     catch (Exception ex)
                     {

backend/src/Squidex.Domain.Apps.Entities.MongoDb/Rules/MongoRuleEventRepository.cs

@@ -9,7 +9,6 @@ using System;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
-using MongoDB.Bson.Serialization;
 using MongoDB.Driver;
 using NodaTime;
 using Squidex.Domain.Apps.Core.HandleRules;

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

@@ -74,9 +74,9 @@ namespace Squidex.Domain.Apps.Entities.Rules
             {
                 var jobs = await ruleService.CreateJobsAsync(rule, ruleId, @event);
 
-                foreach (var job in jobs)
+                foreach (var (job, ex) in jobs)
                 {
-                    if (job.Exception != null)
+                    if (ex != null)
                     {
                         await ruleEventRepository.EnqueueAsync(job, null);
 
@@ -84,7 +84,7 @@ namespace Squidex.Domain.Apps.Entities.Rules
                         {
                             JobResult = RuleJobResult.Failed,
                             ExecutionResult = RuleResult.Failed,
-                            ExecutionDump = job.Exception.ToString(),
+                            ExecutionDump = ex.ToString(),
                             Finished = job.Created
                         });
                     }

backend/tests/Squidex.Domain.Apps.Core.Tests/Operations/HandleRules/RuleServiceTests.cs

@@ -187,7 +187,7 @@ namespace Squidex.Domain.Apps.Core.Operations.HandleRules
             A.CallTo(() => ruleTriggerHandler.Trigger(@event.Payload, rule.Trigger, ruleId))
                 .Returns(true);
 
-            A.CallTo(() => ruleTriggerHandler.CreateEnrichedEventsAsync(A<Envelope<AppEvent>>.That.Matches(x => x.Payload == @event.Payload)))
+            A.CallTo(() => ruleTriggerHandler.CreateEnrichedEventsAsync(MatchPayload(@event)))
                 .Returns(new List<EnrichedEvent>());
 
             var jobs = await sut.CreateJobsAsync(rule, ruleId, @event);
@@ -207,7 +207,7 @@ namespace Squidex.Domain.Apps.Core.Operations.HandleRules
             A.CallTo(() => ruleTriggerHandler.Trigger(@event.Payload, rule.Trigger, ruleId))
                 .Returns(true);
 
-            A.CallTo(() => ruleTriggerHandler.CreateEnrichedEventsAsync(A<Envelope<AppEvent>>.That.Matches(x => x.Payload == @event.Payload)))
+            A.CallTo(() => ruleTriggerHandler.CreateEnrichedEventsAsync(MatchPayload(@event)))
                 .Returns(new List<EnrichedEvent> { enrichedEvent });
 
             A.CallTo(() => ruleTriggerHandler.Trigger(enrichedEvent, rule.Trigger))
@@ -232,7 +232,7 @@ namespace Squidex.Domain.Apps.Core.Operations.HandleRules
             A.CallTo(() => ruleTriggerHandler.Trigger(@event.Payload, rule.Trigger, ruleId))
                 .Returns(true);
 
-            A.CallTo(() => ruleTriggerHandler.CreateEnrichedEventsAsync(A<Envelope<AppEvent>>.That.Matches(x => x.Payload == @event.Payload)))
+            A.CallTo(() => ruleTriggerHandler.CreateEnrichedEventsAsync(MatchPayload(@event)))
                 .Returns(new List<EnrichedEvent> { enrichedEvent });
 
             A.CallTo(() => ruleTriggerHandler.Trigger(enrichedEvent, rule.Trigger))
@@ -241,13 +241,48 @@ namespace Squidex.Domain.Apps.Core.Operations.HandleRules
             A.CallTo(() => ruleActionHandler.CreateJobAsync(enrichedEvent, rule.Action))
                 .Returns((actionDescription, new ValidData { Value = 10 }));
 
-            var jobs = (await sut.CreateJobsAsync(rule, ruleId, @event))!;
+            var jobs = await sut.CreateJobsAsync(rule, ruleId, @event);
 
-            var job = jobs.Single();
+            var (job, _) = jobs.Single();
 
             AssertJob(now, enrichedEvent, job);
 
-            A.CallTo(() => eventEnricher.EnrichAsync(enrichedEvent, A<Envelope<AppEvent>>.That.Matches(x => x.Payload == @event.Payload)))
+            A.CallTo(() => eventEnricher.EnrichAsync(enrichedEvent, MatchPayload(@event)))
+                .MustHaveHappened();
+        }
+
+        [Fact]
+        public async Task Should_create_job_with_exception_if_trigger_failed()
+        {
+            var now = clock.GetCurrentInstant();
+
+            var rule = ValidRule();
+
+            var enrichedEvent = new EnrichedContentEvent { AppId = appId };
+
+            var @event = Envelope.Create(new ContentCreated()).SetTimestamp(now);
+
+            A.CallTo(() => ruleTriggerHandler.Trigger(@event.Payload, rule.Trigger, ruleId))
+                .Returns(true);
+
+            A.CallTo(() => ruleTriggerHandler.CreateEnrichedEventsAsync(MatchPayload(@event)))
+                .Returns(new List<EnrichedEvent> { enrichedEvent });
+
+            A.CallTo(() => ruleTriggerHandler.Trigger(enrichedEvent, rule.Trigger))
+                .Returns(true);
+
+            A.CallTo(() => ruleActionHandler.CreateJobAsync(enrichedEvent, rule.Action))
+                .Throws(new InvalidOperationException());
+
+            var jobs = await sut.CreateJobsAsync(rule, ruleId, @event);
+
+            var (job, ex) = jobs.Single();
+
+            Assert.NotNull(ex);
+            Assert.NotNull(job.ActionData);
+            Assert.NotNull(job.Description);
+
+            A.CallTo(() => eventEnricher.EnrichAsync(enrichedEvent, MatchPayload(@event)))
                 .MustHaveHappened();
         }
 
@@ -266,7 +301,7 @@ namespace Squidex.Domain.Apps.Core.Operations.HandleRules
             A.CallTo(() => ruleTriggerHandler.Trigger(@event.Payload, rule.Trigger, ruleId))
                 .Returns(true);
 
-            A.CallTo(() => ruleTriggerHandler.CreateEnrichedEventsAsync(A<Envelope<AppEvent>>.That.Matches(x => x.Payload == @event.Payload)))
+            A.CallTo(() => ruleTriggerHandler.CreateEnrichedEventsAsync(MatchPayload(@event)))
                 .Returns(new List<EnrichedEvent> { enrichedEvent1, enrichedEvent2 });
 
             A.CallTo(() => ruleTriggerHandler.Trigger(enrichedEvent1, rule.Trigger))
@@ -281,15 +316,15 @@ namespace Squidex.Domain.Apps.Core.Operations.HandleRules
             A.CallTo(() => ruleActionHandler.CreateJobAsync(enrichedEvent2, rule.Action))
                 .Returns((actionDescription, new ValidData { Value = 10 }));
 
-            var jobs = (await sut.CreateJobsAsync(rule, ruleId, @event))!;
+            var jobs = await sut.CreateJobsAsync(rule, ruleId, @event);
 
-            AssertJob(now, enrichedEvent1, jobs[0]);
-            AssertJob(now, enrichedEvent1, jobs[1]);
+            AssertJob(now, enrichedEvent1, jobs[0].Job);
+            AssertJob(now, enrichedEvent1, jobs[1].Job);
 
-            A.CallTo(() => eventEnricher.EnrichAsync(enrichedEvent1, A<Envelope<AppEvent>>.That.Matches(x => x.Payload == @event.Payload)))
+            A.CallTo(() => eventEnricher.EnrichAsync(enrichedEvent1, MatchPayload(@event)))
                 .MustHaveHappened();
 
-            A.CallTo(() => eventEnricher.EnrichAsync(enrichedEvent2, A<Envelope<AppEvent>>.That.Matches(x => x.Payload == @event.Payload)))
+            A.CallTo(() => eventEnricher.EnrichAsync(enrichedEvent2, MatchPayload(@event)))
                 .MustHaveHappened();
         }
 
@@ -365,6 +400,11 @@ namespace Squidex.Domain.Apps.Core.Operations.HandleRules
             return new Rule(new ContentChangedTriggerV2(), new ValidAction());
         }
 
+        private static Envelope<AppEvent> MatchPayload(Envelope<ContentCreated> @event)
+        {
+            return A<Envelope<AppEvent>>.That.Matches(x => x.Payload == @event.Payload);
+        }
+
         private void AssertJob(Instant now, EnrichedContentEvent enrichedEvent, RuleJob job)
         {
             Assert.Equal(enrichedEvent.AppId.Id, job.AppId);