Create a legacy event when a new SupportTaskCreatedEvent is created (#2870)

We're moving support tasks to the new style events but we still have a
bunch of places looking for the legacy events (Change History UI,
reporting etc.). This adds an event handler that will create a legacy
`SupportTaskCreatedEvent` when a new `SupportTaskCreatedEvent` is
published.

Author: gunndabad

TeachingRecordSystem/src/TeachingRecordSystem.Core/EventHandlers/CreateLegacySupportTaskEvents.cs

@@ -0,0 +1,21 @@
+using TeachingRecordSystem.Core.DataStore.Postgres;
+
+namespace TeachingRecordSystem.Core.EventHandlers;
+
+public class CreateLegacySupportTaskEvents(TrsDbContext dbContext) : IEventHandler<SupportTaskCreatedEvent>
+{
+    public async Task HandleEventAsync(SupportTaskCreatedEvent @event, ProcessContext processContext)
+    {
+        var legacyEvent = new LegacyEvents.SupportTaskCreatedEvent
+        {
+            EventId = @event.EventId,
+            CreatedUtc = processContext.Now,
+            RaisedBy = processContext.Process.UserId!,
+            SupportTask = @event.SupportTask
+        };
+
+        dbContext.AddEventWithoutBroadcast(legacyEvent);
+
+        await dbContext.SaveChangesAsync();
+    }
+}

TeachingRecordSystem/src/TeachingRecordSystem.Core/EventPublisher.cs

@@ -44,6 +44,23 @@ private async Task InvokeEventHandlersAsync(IEvent @event, ProcessContext proces
         {
             await handler.HandleEventAsync(@event, processContext);
         }
+
+        var eventType = @event.GetType();
+        var typeSpecificHandlers = serviceProvider.GetServices(typeof(IEventHandler<>).MakeGenericType(eventType));
+
+        foreach (var handler in typeSpecificHandlers)
+        {
+            var wrapper = (IEventHandler)Activator.CreateInstance(typeof(TypedHandlerWrapper<>).MakeGenericType(eventType), handler)!;
+            await wrapper.HandleEventAsync(@event, processContext);
+        }
+    }
+
+    private class TypedHandlerWrapper<TEvent>(IEventHandler<TEvent> innerHandler) : IEventHandler where TEvent : IEvent
+    {
+        public Task HandleEventAsync(IEvent @event, ProcessContext processContext)
+        {
+            return innerHandler.HandleEventAsync(((TEvent)@event), processContext);
+        }
     }
 }
 

TeachingRecordSystem/src/TeachingRecordSystem.Core/Extensions.cs

@@ -146,6 +146,7 @@ public static IServiceCollection AddEventPublisher(this IServiceCollection servi
 
         services.Scan(s => s.FromAssemblyOf<IEvent>()
             .AddClasses(c => c.AssignableTo<IEventHandler>())
+            .AddClasses(c => c.AssignableTo(typeof(IEventHandler<>)))
             .AsImplementedInterfaces()
             .WithTransientLifetime());
 

TeachingRecordSystem/src/TeachingRecordSystem.Core/IEventHandler.cs

@@ -6,3 +6,8 @@ public interface IEventHandler
 {
     Task HandleEventAsync(IEvent @event, ProcessContext processContext);
 }
+
+public interface IEventHandler<TEvent> where TEvent : IEvent
+{
+    Task HandleEventAsync(TEvent @event, ProcessContext processContext);
+}

TeachingRecordSystem/tests/TeachingRecordSystem.Core.Tests/EventPipelineTests/EventPipelineFixture.cs

@@ -0,0 +1,23 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using TeachingRecordSystem.Core.Tests.EventPipelineTests;
+using TeachingRecordSystem.TestCommon.Infrastructure;
+
+[assembly: AssemblyFixture(typeof(EventPipelineFixture))]
+
+namespace TeachingRecordSystem.Core.Tests.EventPipelineTests;
+
+public class EventPipelineFixture : ServiceProviderFixture
+{
+    protected override void ConfigureServices(IServiceCollection services, IConfiguration configuration)
+    {
+        services
+            .AddSingleton<TestData>()
+            .AddSingleton<ReferenceDataCache>()
+            .AddEventPublisher();
+
+        PublishEventsDbCommandInterceptor.ConfigureServices(services);
+
+        TestScopedServices.ConfigureServices(services);
+    }
+}

TeachingRecordSystem/tests/TeachingRecordSystem.Core.Tests/EventPipelineTests/EventPipelineTestBase.cs

@@ -0,0 +1,30 @@
+using Microsoft.Extensions.DependencyInjection;
+using TeachingRecordSystem.Core.DataStore.Postgres;
+
+namespace TeachingRecordSystem.Core.Tests.EventPipelineTests;
+
+public class EventPipelineTestBase
+{
+    private readonly EventPipelineFixture _fixture;
+
+    protected EventPipelineTestBase(EventPipelineFixture fixture)
+    {
+        _fixture = fixture;
+
+        TestScopedServices.Reset();
+    }
+
+    protected TestableClock Clock => TestScopedServices.GetCurrent().Clock;
+
+    protected IDbContextFactory<TrsDbContext> DbContextFactory => _fixture.Services.GetRequiredService<IDbContextFactory<TrsDbContext>>();
+
+    protected EventCapture Events => _fixture.Services.GetRequiredService<EventCapture>();
+
+    protected IEventPublisher EventPublisher => _fixture.Services.GetRequiredService<IEventPublisher>();
+
+    protected CaptureEventObserver LegacyEventObserver => TestScopedServices.GetCurrent().LegacyEventObserver;
+
+    protected IServiceProvider Services => _fixture.Services;
+
+    protected TestData TestData => Services.GetRequiredService<TestData>();
+}

TeachingRecordSystem/tests/TeachingRecordSystem.Core.Tests/EventPipelineTests/SupportTaskEventPipelineTests.cs

@@ -0,0 +1,50 @@
+using Optional.Unsafe;
+using TeachingRecordSystem.Core.DataStore.Postgres.Models;
+using TeachingRecordSystem.Core.Models.SupportTasks;
+
+namespace TeachingRecordSystem.Core.Tests.EventPipelineTests;
+
+public class SupportTaskEventPipelineTests(EventPipelineFixture fixture) : EventPipelineTestBase(fixture)
+{
+    [Fact]
+    public async Task SupportTaskCreatedEventPublished_EmitsLegacySupportTaskCreatedEvent()
+    {
+        // Arrange
+        var processContext = new ProcessContext(default, Clock.UtcNow, SystemUser.SystemUserId);
+
+        var @event = new SupportTaskCreatedEvent
+        {
+            EventId = Guid.NewGuid(),
+            SupportTask = new EventModels.SupportTask
+            {
+                SupportTaskReference = "ABC-123",
+                SupportTaskType = SupportTaskType.ChangeDateOfBirthRequest,
+                Status = SupportTaskStatus.Open,
+                OneLoginUserSubject = null,
+                PersonId = Guid.NewGuid(),
+                Data = new ChangeDateOfBirthRequestData
+                {
+                    DateOfBirth = new(2000, 1, 1),
+                    EvidenceFileId = Guid.NewGuid(),
+                    EvidenceFileName = "evidence.jpeg",
+                    EmailAddress = TestData.GenerateUniqueEmail(),
+                    ChangeRequestOutcome = null
+                }
+            }
+        };
+
+        // Act
+        await EventPublisher.PublishEventAsync(@event, processContext);
+
+        // Assert
+        LegacyEventObserver.AssertEventsSaved(
+            e =>
+            {
+                var legacyEvent = Assert.IsType<LegacyEvents.SupportTaskCreatedEvent>(e);
+                Assert.Equal(@event.EventId, legacyEvent.EventId);
+                Assert.Equal(@event.SupportTask, legacyEvent.SupportTask);
+                Assert.Equal(processContext.Now, legacyEvent.CreatedUtc);
+                Assert.Equal(@event.PersonIds.SingleOrDefault(), legacyEvent.PersonId.ToNullable());
+            });
+    }
+}

TeachingRecordSystem/tests/TeachingRecordSystem.Core.Tests/EventPipelineTests/TestScopedServices.cs

@@ -0,0 +1,74 @@
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.Extensions.DependencyInjection;
+using TeachingRecordSystem.TestCommon.Infrastructure;
+
+namespace TeachingRecordSystem.Core.Tests.EventPipelineTests;
+
+public class TestScopedServices
+{
+    private static readonly AsyncLocal<TestScopedServices> _current = new();
+
+    public TestScopedServices()
+    {
+        Clock = new();
+        Events = new();
+        LegacyEventObserver = new();
+    }
+
+    public TestableClock Clock { get; }
+
+    public EventCapture Events { get; }
+
+    public CaptureEventObserver LegacyEventObserver { get; }
+
+    public static void ConfigureServices(IServiceCollection services) =>
+        services
+            .AddSingleton<IClock>(new ForwardToTestScopedClock())
+            .AddTestScoped<EventCapture>(tss => tss.Events)
+            .AddTransient<IEventHandler>(sp => sp.GetRequiredService<EventCapture>())
+            .AddSingleton<IEventObserver>(new ForwardToTestScopedEventObserver());
+
+    public static TestScopedServices GetCurrent() =>
+        TryGetCurrent(out var current) ? current : throw new InvalidOperationException("No current instance has been set.");
+
+    public static TestScopedServices Reset()
+    {
+        if (_current.Value is not null)
+        {
+            throw new InvalidOperationException("Current instance has already been set.");
+        }
+
+        return _current.Value = new();
+    }
+
+    public static bool TryGetCurrent([NotNullWhen(true)] out TestScopedServices? current)
+    {
+        if (_current.Value is TestScopedServices tss)
+        {
+            current = tss;
+            return true;
+        }
+
+        current = default;
+        return false;
+    }
+
+    private class ForwardToTestScopedClock : IClock
+    {
+        public DateTime UtcNow => GetCurrent().Clock.UtcNow;
+    }
+
+    private class ForwardToTestScopedEventObserver : IEventObserver
+    {
+        public void OnEventCreated(LegacyEvents.EventBase @event) => GetCurrent().LegacyEventObserver.OnEventCreated(@event);
+    }
+}
+
+file static class ServiceCollectionExtensions
+{
+    public static IServiceCollection AddTestScoped<T>(this IServiceCollection services, Func<TestScopedServices, T> resolveService)
+        where T : class
+    {
+        return services.AddTransient(_ => resolveService(TestScopedServices.GetCurrent()));
+    }
+}