Added Mediator and Quartz components

PostFundManagement.Domain/Quartz/JobOrchestrator.cs

@@ -0,0 +1,87 @@
+using PostFundManagement.Domain.Abstractions;
+
+namespace PostFundManagement.Domain.Quartz;
+
+public sealed class JobOrchestrator(ISchedulerFactory schedulerFactory) : IJobOrchestrator
+{
+    public async ValueTask SendAsync<TNotification>(TNotification notification, CancellationToken cancellationToken = default)
+        where TNotification : IEvent
+    {
+        var chainedJobGroup = "onetime-jobs";
+
+        var scheduler = await schedulerFactory.GetScheduler(cancellationToken);
+        var jobKey = new JobKey($"{notification.Name.ToLower(CultureInfo.InvariantCulture)}-{notification.CorrelationId.ToLower(CultureInfo.InvariantCulture)}", chainedJobGroup);
+        var triggerKey = new TriggerKey($"{jobKey.Name}-trigger", chainedJobGroup);
+
+        var job = JobBuilder.Create<MediatorJob<TNotification>>()
+            .WithIdentity(jobKey)
+            .WithDescription($"Correlation ID: {notification.CorrelationId}")
+            .UsingJobData(new JobDataMap { ["Payload"] = JsonSerializer.Serialize(notification) })
+            .DisallowConcurrentExecution()
+            .RequestRecovery()
+            .Build();
+
+        var trigger = global::Quartz.TriggerBuilder.Create()
+            .WithIdentity(triggerKey)
+            .StartNow()
+            .Build();
+
+        await scheduler.ScheduleJob(job, new List<ITrigger> { trigger }.AsReadOnly(), replace: true, cancellationToken);
+    }
+
+    public async ValueTask ScheduleAsync<TNotification>(TNotification notification, string cronExpression, CancellationToken cancellationToken = default)
+        where TNotification : IEvent
+    {
+        var chainedJobGroup = "scheduled-jobs";
+
+        var scheduler = await schedulerFactory.GetScheduler(cancellationToken);
+        var jobKey = new JobKey($"{notification.Name.ToLower(CultureInfo.InvariantCulture)}", chainedJobGroup);
+        var triggerKey = new TriggerKey($"{jobKey.Name}-trigger", chainedJobGroup);
+
+        var job = JobBuilder.Create<MediatorJob<TNotification>>()
+            .WithIdentity(jobKey)
+            .WithDescription($"Correlation ID: {notification.CorrelationId}")
+            .UsingJobData(new JobDataMap { ["Payload"] = JsonSerializer.Serialize(notification) })
+            .DisallowConcurrentExecution()
+            .StoreDurably()
+            .Build();
+
+        var now = DateTime.UtcNow;
+
+        var trigger = global::Quartz.TriggerBuilder.Create()
+            .WithIdentity(triggerKey)
+            .WithDescription($"Scheduled via Main Job at {now:g}")
+            .WithCronSchedule(cronExpression, cron => cron
+                .WithMisfireHandlingInstructionIgnoreMisfires())
+            .StartAt((DateTimeOffset)now)
+            .Build();
+
+        await scheduler.AddJob(job, replace: true, cancellationToken);
+
+        if (await scheduler.CheckExists(triggerKey, cancellationToken))
+            await scheduler.RescheduleJob(triggerKey, trigger, cancellationToken);
+        else
+            await scheduler.ScheduleJob(job, new List<ITrigger> { trigger }.AsReadOnly(), replace: true, cancellationToken);
+    }
+
+    public async ValueTask<bool> InterruptAsync(string eventName, string? correlationId = null, CancellationToken cancellationToken = default)
+    {
+        var scheduler = await schedulerFactory.GetScheduler(cancellationToken);
+
+        var jobKeyName = string.Empty;
+        var jobGroup = string.Empty;
+
+        if (!string.IsNullOrWhiteSpace(correlationId))
+        {
+            jobKeyName = $"{eventName.ToLower(CultureInfo.InvariantCulture)}-{correlationId.ToLower(CultureInfo.InvariantCulture)}";
+            jobGroup = "onetime-jobs";
+        }
+        else
+        {
+            jobKeyName = eventName.ToLower(CultureInfo.InvariantCulture);
+            jobGroup = "scheduled-jobs";
+        }
+
+        return await scheduler.Interrupt(JobKey.Create(jobKeyName, jobGroup), cancellationToken);
+    }
+}

PostFundManagement.Domain/Quartz/MediatorJob.cs

@@ -0,0 +1,52 @@
+using System.Diagnostics;
+using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Domain.Extensions;
+
+namespace PostFundManagement.Domain.Quartz;
+
+[DisallowConcurrentExecution]
+public sealed class MediatorJob<TNotification>(IMediator mediator) : IJob where TNotification : IEvent
+{
+    public async Task Execute(IJobExecutionContext context)
+    {
+        if (context.Recovering)
+            Trace.WriteLine($"CRITICAL RECOVERY: Resurrecting job '{typeof(TNotification).Name}' after a previous cluster node crashed mid-execution.");
+
+        var data = context.MergedJobDataMap["Payload"] as string;
+
+        if (string.IsNullOrWhiteSpace(data))
+        {
+            Trace.WriteLine("Job Payload missing, job ended");
+
+            return;
+        }
+
+        var notification = JsonSerializer.Deserialize<TNotification>(data);
+
+        if (notification is null)
+        {
+            Trace.WriteLine("Notification could not be Json converted from data string, job ended");
+
+            return;
+        }
+
+        using var activity = MediatorTelemetry.Source.StartActivity(typeof(TNotification).Name);
+
+        activity?.SetTag("event.correlation_id", notification.CorrelationId);
+
+        try
+        {
+            await mediator.Publish(notification, context.CancellationToken);
+
+            Trace.WriteLine("Job published successfully");
+        }
+        catch (OperationCanceledException) when (context.CancellationToken.IsCancellationRequested)
+        {
+            Trace.WriteLine($"Job '{typeof(TNotification).Name}' was gracefully interrupted by the cluster control plane.");
+            
+            activity?.SetStatus(ActivityStatusCode.Ok);
+
+            return;
+        }
+    }
+}

PostFundManagement.Domain/Quartz/RetryJobListener.cs

@@ -0,0 +1,21 @@
+namespace PostFundManagement.Domain.Quartz;
+
+public sealed class RetryJobListener : IJobListener
+{
+    public string Name => "RetryJobListener";
+
+    public int RetryCount { get; set; } = 3;
+
+    public Task JobExecutionVetoed(IJobExecutionContext context, CancellationToken cancellationToken = default) => Task.CompletedTask;
+
+    public Task JobToBeExecuted(IJobExecutionContext context, CancellationToken cancellationToken = default) => Task.CompletedTask;
+
+    public async Task JobWasExecuted(IJobExecutionContext context, JobExecutionException? jobException, CancellationToken cancellationToken = default)
+    {
+        if (context.CancellationToken.IsCancellationRequested)
+            return;
+
+        if (jobException is not null && context.RefireCount < RetryCount)
+            jobException.RefireImmediately = true;
+    }
+}