Fixes (#1148)

* Small fix for parent ID

* Get rid of unnecessary step.

.github/workflows/dev.yml

@@ -108,13 +108,6 @@ jobs:
           path: tools/e2e/playwright-report/
           retention-days: 30
        
-      - name: Test - Upload Screenshots
-        if: failure()
-        uses: actions/upload-artifact@v4.4.3
-        with:
-          path: |
-            tools/TestSuite/TestSuite.ApiTests/bin/Debug/net8.0/screenshots/
-       
       - name: Test - Dump docker logs on failure
         if: failure()
         uses: jwalton/gh-docker-logs@v2.2.2

backend/src/Squidex.Domain.Apps.Core.Model/Rules/EnrichedEvents/EnrichedAssetEvent.cs

@@ -32,7 +32,7 @@ public sealed class EnrichedAssetEvent : EnrichedUserEventBase, IEnrichedEntityE
     public RefToken LastModifiedBy { get; set; }
 
     [FieldDescription(nameof(FieldDescriptions.AssetParentId))]
-    public DomainId ParentId { get; }
+    public DomainId ParentId { get; set; }
 
     [FieldDescription(nameof(FieldDescriptions.AssetMimeType))]
     public string MimeType { get; set; }

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

@@ -23,7 +23,7 @@ using Squidex.Infrastructure.Tasks;
 namespace Squidex.Domain.Apps.Core.HandleRules;
 
 public sealed class RuleService(
-    IOptions<RuleOptions> ruleOptions,
+    IOptions<RulesOptions> options,
     IEnumerable<IRuleTriggerHandler> ruleTriggerHandlers,
     IEnumerable<IRuleActionHandler> ruleActionHandlers,
     IEventEnricher eventEnricher,
@@ -34,7 +34,7 @@ public sealed class RuleService(
 {
     private readonly Dictionary<Type, IRuleActionHandler> ruleActionHandlers = ruleActionHandlers.ToDictionary(x => x.ActionType);
     private readonly Dictionary<Type, IRuleTriggerHandler> ruleTriggerHandlers = ruleTriggerHandlers.ToDictionary(x => x.TriggerType);
-    private readonly RuleOptions ruleOptions = ruleOptions.Value;
+    private readonly RulesOptions options = options.Value;
 
     private sealed class RuleState
     {
@@ -451,6 +451,6 @@ public sealed class RuleService(
 
     private int GetTimeoutInMs()
     {
-        return ruleOptions.ExecutionTimeoutInSeconds * 1000;
+        return options.ExecutionTimeoutInSeconds * 1000;
     }
 }

backend/src/Squidex.Domain.Apps.Core.Operations/HandleRules/RuleOptions.cs → backend/src/Squidex.Domain.Apps.Core.Operations/HandleRules/RulesOptions.cs

@@ -7,11 +7,13 @@
 
 namespace Squidex.Domain.Apps.Core.HandleRules;
 
-public sealed class RuleOptions
+public sealed class RulesOptions
 {
     public int ExecutionTimeoutInSeconds { get; set; } = 3;
 
     public int MaxEnrichedEvents { get; set; } = 500;
 
+    public TimeSpan JobQueryInterval { get; set; } = TimeSpan.FromSeconds(10);
+
     public TimeSpan RulesCacheDuration { get; set; } = TimeSpan.FromSeconds(10);
 }

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

@@ -7,6 +7,7 @@
 
 using System.Collections.Concurrent;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 using NodaTime;
 using Squidex.Domain.Apps.Core.HandleRules;
 using Squidex.Domain.Apps.Core.Rules;
@@ -22,6 +23,7 @@ public sealed class RuleDequeuerWorker : IBackgroundProcess
 {
     private readonly ConcurrentDictionary<DomainId, bool> executing = new ConcurrentDictionary<DomainId, bool>();
     private readonly PartitionedScheduler<IRuleEventEntity> requestScheduler;
+    private readonly RulesOptions options;
     private readonly IRuleEventRepository ruleEventRepository;
     private readonly IRuleService ruleService;
     private readonly IRuleUsageTracker ruleUsageTracker;
@@ -34,11 +36,13 @@ public sealed class RuleDequeuerWorker : IBackgroundProcess
         IRuleService ruleService,
         IRuleUsageTracker ruleUsageTracker,
         IRuleEventRepository ruleEventRepository,
+        IOptions<RulesOptions> options,
         ILogger<RuleDequeuerWorker> log)
     {
         this.ruleEventRepository = ruleEventRepository;
         this.ruleService = ruleService;
         this.ruleUsageTracker = ruleUsageTracker;
+        this.options = options.Value;
         this.log = log;
 
         requestScheduler = new PartitionedScheduler<IRuleEventEntity>(HandleAsync, 32, 2);
@@ -47,7 +51,7 @@ public sealed class RuleDequeuerWorker : IBackgroundProcess
     public Task StartAsync(
         CancellationToken ct)
     {
-        timer = new CompletionTimer((int)TimeSpan.FromSeconds(10).TotalMilliseconds, QueryAsync);
+        timer = new CompletionTimer((int)options.JobQueryInterval.TotalMilliseconds, QueryAsync);
 
         return Task.CompletedTask;
     }

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

@@ -26,7 +26,7 @@ public sealed class RuleEnqueuer(
     IRuleEventRepository ruleEventRepository,
     IRuleService ruleService,
     IRuleUsageTracker ruleUsageTracker,
-    IOptions<RuleOptions> options,
+    IOptions<RulesOptions> options,
     ILogger<RuleEnqueuer> log)
     : IEventConsumer, IRuleEnqueuer
 {

backend/src/Squidex.Domain.Apps.Entities/Rules/Runner/DefaultRuleRunnerService.cs

@@ -63,7 +63,7 @@ public sealed class DefaultRuleRunnerService(
                 continue;
             }
 
-            // Also create jobs for rules with failing conditions because we want to show them in th table.
+            // Also create jobs for rules with failing conditions because we want to show them in the table.
             await foreach (var job in ruleService.CreateJobsAsync(@event, context, ct).Take(MaxSimulatedEvents).WithCancellation(ct))
             {
                 var eventName = job.Job?.EventName;

backend/src/Squidex/Config/Domain/RuleServices.cs

@@ -29,7 +29,7 @@ public static class RuleServices
 {
     public static void AddSquidexRules(this IServiceCollection services, IConfiguration config)
     {
-        services.Configure<RuleOptions>(config,
+        services.Configure<RulesOptions>(config,
             "rules");
 
         services.AddSingletonAs<EventEnricher>()

backend/src/Squidex/appsettings.json

@@ -121,7 +121,10 @@
         "executionTimeoutInSeconds": 10,
 
         // The cache duration for rules.
-        "rulesCacheDuration": "00:00:10"
+        "rulesCacheDuration": "00:00:10",
+
+        // How often the rule jobs are queried for updated. Must be greater than zero.
+        "jobQueryInterval": "00:00:10"
     },
 
     "ui": {

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

@@ -80,7 +80,8 @@ public class RuleServiceTests
 
         var log = A.Fake<ILogger<RuleService>>();
 
-        sut = new RuleService(Options.Create(new RuleOptions()),
+        sut = new RuleService(
+            Options.Create(new RulesOptions()),
             [ruleTriggerHandler],
             [ruleActionHandler],
             eventEnricher, TestUtils.DefaultSerializer, log, typeRegistry)

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

@@ -6,6 +6,7 @@
 // ==========================================================================
 
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 using NodaTime;
 using Squidex.Domain.Apps.Core.HandleRules;
 using Squidex.Domain.Apps.Core.Rules;
@@ -28,7 +29,12 @@ public class RuleDequeuerWorkerTests
         A.CallTo(() => clock.GetCurrentInstant())
             .Returns(SystemClock.Instance.GetCurrentInstant().WithoutMs());
 
-        sut = new RuleDequeuerWorker(ruleService, ruleUsageTracker, ruleEventRepository, log)
+        sut = new RuleDequeuerWorker(
+            ruleService,
+            ruleUsageTracker,
+            ruleEventRepository,
+            Options.Create(new RulesOptions()),
+            log)
         {
             Clock = clock
         };

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

@@ -37,7 +37,7 @@ public class RuleEnqueuerTests : GivenContext
 
     public RuleEnqueuerTests()
     {
-        var options = Options.Create(new RuleOptions());
+        var options = Options.Create(new RulesOptions());
 
         sut = new RuleEnqueuer(cache, A.Fake<ILocalCache>(),
             AppProvider,