Refactor LicenseManager registration with factory

Replaces transient LicenseManager registration (with per-injection license key retrieval via MediatR) with a singleton LicenseManagerFactory. This centralizes license management and may improve performance and maintainability.

EnvelopeGenerator.Application/ThirdPartyModules/Queries/ReadThirdPartyModuleLicenseQuery.cs

@@ -0,0 +1,92 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.Core.Exceptions;
+using EnvelopeGenerator.Domain.Entities;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+
+namespace EnvelopeGenerator.Application.ThirdPartyModules.Queries;
+
+/// <summary>
+/// Query to read the license text of a third-party module.
+/// Either <see cref="Id"/> or <see cref="Name"/> must be provided, but not both.
+/// </summary>
+public record ReadThirdPartyModuleLicenseQuery : IRequest<string>
+{
+    /// <summary>
+    /// The unique identifier of the third-party module (optional).
+    /// </summary>
+    public int? Id { get; init; }
+
+    /// <summary>
+    /// The name of the third-party module (optional).
+    /// </summary>
+    public string? Name { get; init; }
+
+    /// <summary>
+    /// Whether to filter only active modules. Defaults to <c>true</c>.
+    /// </summary>
+    public bool Active { get; init; } = true;
+}
+
+/// <summary>
+/// Handles <see cref="ReadThirdPartyModuleLicenseQuery"/> and returns the license text of a third-party module.
+/// </summary>
+public class ReadThirdPartyModuleLicenseQueryHandler : IRequestHandler<ReadThirdPartyModuleLicenseQuery, string>
+{
+    private readonly IRepository<ThirdPartyModule> _repository;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ReadThirdPartyModuleLicenseQueryHandler"/> class.
+    /// </summary>
+    /// <param name="repository">The repository for accessing third-party modules.</param>
+    public ReadThirdPartyModuleLicenseQueryHandler(IRepository<ThirdPartyModule> repository)
+    {
+        _repository = repository;
+    }
+
+    /// <summary>
+    /// Handles the query by filtering on Id or Name and returning the license text.
+    /// </summary>
+    /// <param name="request">The query parameters.</param>
+    /// <param name="cancel">A cancellation token.</param>
+    /// <returns>The license text of the matching third-party module.</returns>
+    /// <exception cref="BadRequestException">
+    /// Thrown when neither Id nor Name is provided, or when both are provided.
+    /// </exception>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown when multiple modules match the given criteria, indicating a data integrity issue.
+    /// </exception>
+    /// <exception cref="NotFoundException">
+    /// Thrown when no module matches the given criteria.
+    /// </exception>
+    public async Task<string> Handle(ReadThirdPartyModuleLicenseQuery request, CancellationToken cancel)
+    {
+        if (request.Id is null && request.Name is null)
+            throw new BadRequestException("Either Id or Name must be provided.");
+
+        if (request.Id is not null && request.Name is not null)
+            throw new BadRequestException("Only one of Id or Name must be provided, not both.");
+
+        var query = _repository.Query
+            .Where(m => m.Active == request.Active);
+
+        if (request.Id is int id)
+            query = query.Where(m => m.Id == id);
+
+        if (request.Name is string name)
+            query = query.Where(m => m.Name == name);
+
+        var modules = await query
+            .Take(2)
+            .ToListAsync(cancel);
+
+        if (modules.Count > 1)
+            throw new InvalidOperationException(
+                $"Data integrity violation: multiple third-party modules found for the given criteria (Id={request.Id}, Name={request.Name}, Active={request.Active}).");
+
+        return modules.SingleOrDefault() is ThirdPartyModule module
+            ? module.License
+            : throw new NotFoundException(
+                $"Third-party module not found for the given criteria (Id={request.Id}, Name={request.Name}, Active={request.Active}).");
+    }
+}

EnvelopeGenerator.Domain/Entities/ThirdPartyModule.cs

@@ -0,0 +1,61 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using EnvelopeGenerator.Domain.Interfaces.Auditing;
+#if NETFRAMEWORK
+using System;
+#endif
+
+namespace EnvelopeGenerator.Domain.Entities
+{
+    [Table("TBDD_3RD_PARTY_MODULES", Schema = "dbo")]
+    public class ThirdPartyModule : IHasChangedWhen, IHasChangedWho
+    {
+        [Key]
+        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+        [Column("GUID")]
+        public int Id { get; set; }
+
+        [Required]
+        [Column("ACTIVE", TypeName = "bit")]
+        public bool Active { get; set; }
+
+        [Required]
+        [Column("NAME", TypeName = "varchar(50)")]
+        public string Name { get; set; }
+
+        [Column("DESCRIPTION", TypeName = "varchar(500)")]
+        public string
+#if nullable
+        ?
+#endif
+            Description { get; set; }
+
+        [Required]
+        [Column("LICENSE", TypeName = "varchar(max)")]
+        public string License { get; set; }
+
+        [Required]
+        [Column("VERSION", TypeName = "varchar(20)")]
+        public string Version { get; set; }
+        
+        [Column("ADDED_WHO", TypeName = "varchar(50)")]
+        public string
+#if nullable
+        ?
+#endif
+            AddedWho { get; set; }
+
+        [Column("ADDED_WHEN", TypeName = "datetime")]
+        public DateTime? AddedWhen { get; set; }
+
+        [Column("CHANGED_WHO", TypeName = "varchar(50)")]
+        public string
+#if nullable
+        ?
+#endif
+            ChangedWho { get; set; }
+
+        [Column("CHANGED_WHEN", TypeName = "datetime")]
+        public DateTime? ChangedWhen { get; set; }
+    }
+}

EnvelopeGenerator.Infrastructure/EGDbContext.cs

@@ -81,6 +81,8 @@ public abstract class EGDbContextBase : DbContext
 
     public DbSet<EnvelopeReport> EnvelopeReports { get; set; }
 
+    public DbSet<ThirdPartyModule> ThirdPartyModules { get; set; }
+
     private readonly DbTriggerParams _triggers;
 
     private readonly ILogger

EnvelopeGenerator.ServiceHost/Controllers/DocResultController.cs

@@ -9,8 +9,13 @@ namespace EnvelopeGenerator.ServiceHost.Controllers;
 public class DocResultController(IMediator mediator) : ControllerBase
 {
     [HttpGet]
-    public async Task<IActionResult> GetAsync([FromQuery] ReadSingleEnvelopeDocResultQuery query, CancellationToken cancel = default)
+    public async Task<IActionResult> GetAsync([FromQuery] ReadSingleEnvelopeDocResultQuery query, [FromQuery] bool download = false, CancellationToken cancel = default)
     {
-        return File(await mediator.Send(query, cancel), "application/pdf", $"envelope_{query.Envelope.Uuid}.pdf");
+        var bytes = await mediator.Send(query, cancel);
+
+        if (download)
+            return File(bytes, "application/pdf", $"envelope_{query.Envelope.Uuid}.pdf");
+
+        return File(bytes, "application/pdf");
     }
 }

EnvelopeGenerator.ServiceHost/Controllers/WorkerController.cs

@@ -1,44 +1,21 @@
-using Microsoft.AspNetCore.Mvc;
+using EnvelopeGenerator.ServiceHost.Jobs;
+using Microsoft.AspNetCore.Mvc;
 
 namespace EnvelopeGenerator.ServiceHost.Controllers;
 
 [Route("api/[controller]")]
 [ApiController]
-public class WorkerController(IEnumerable<IHostedService> hostedServices, ILogger<WorkerController> logger) : ControllerBase
+public class WorkerController(JobStateManager jobStateManager) : ControllerBase
 {
-    private Worker? Worker => hostedServices.OfType<Worker>().FirstOrDefault();
+    private readonly JobStateManager _jobStateManager = jobStateManager;
 
-    [HttpPost("stop")]
-    public async Task<IActionResult> Stop(CancellationToken cancel)
+    [HttpGet(nameof(FinalizeDocumentJob))]
+    public IActionResult GetStateOfFinalizeDocumentJob() => Ok(_jobStateManager.GetState<FinalizeDocumentJob>());
+
+    [HttpPost(nameof(FinalizeDocumentJob))]
+    public IActionResult SetStateOfFinalizeDocumentJob([FromQuery] State state)
     {
-        if (Worker is null)
-            return NotFound();
-
-        logger.LogInformation("Stopping Worker via API request.");
-        await Worker.StopAsync(cancel);
-        return Ok();
-    }
-
-    [HttpPost("start")]
-    public async Task<IActionResult> Start(CancellationToken cancel)
-    {
-        if (Worker is null)
-            return NotFound();
-
-        logger.LogInformation("Starting Worker via API request.");
-        await Worker.StartAsync(cancel);
-        return Ok();
-    }
-
-    [HttpPost("restart")]
-    public async Task<IActionResult> Restart(CancellationToken cancel)
-    {
-        if (Worker is null)
-            return NotFound();
-
-        logger.LogInformation("Restarting Worker via API request.");
-        await Worker.StopAsync(cancel);
-        await Worker.StartAsync(cancel);
+        _jobStateManager.SetState<FinalizeDocumentJob>(state);
         return Ok();
     }
 }

EnvelopeGenerator.ServiceHost/EnvelopeGenerator.ServiceHost.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
+<Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
     <TargetFramework>net8.0-windows</TargetFramework>
@@ -20,7 +20,8 @@
     <PackageReference Include="System.Drawing.Common" Version="8.0.16" />
     <PackageReference Include="Microsoft.Extensions.Options" Version="8.0.2" />
     <PackageReference Include="DevExpress.Reporting.Core" Version="24.2.*" />
-	<PackageReference Include="Microsoft.Extensions.Caching.SqlServer" Version="8.0.17" />
+    <PackageReference Include="Microsoft.Extensions.Caching.SqlServer" Version="8.0.17" />
+	<PackageReference Include="Microsoft.Extensions.Hosting.WindowsServices" Version="8.0.1" />
   </ItemGroup>
 
   <ItemGroup>

EnvelopeGenerator.ServiceHost/Extensions/DependencyInjection.cs

@@ -10,7 +10,13 @@ public static class DependencyInjection
     [Obsolete("Check obsoleted services")]
     public static IServiceCollection AddFinalizeDocumentJob(this IServiceCollection services, IConfiguration configuration)
     {
-        services.Configure<WorkerOptions>(configuration.GetSection(nameof(WorkerOptions)));
+        services.Configure<WorkerOptions>(configuration.GetSection("Worker"));
+        services.AddSingleton(provider =>
+        {
+            var options = provider.GetRequiredService<IOptions<WorkerOptions>>().Value;
+            var manager = new JobStateManager(options.InitialJobState);
+            return manager;
+        });
         services.AddScoped<FinalizeDocumentJob>();
         services.AddScoped<ActionService>();
         services.AddSingleton<TempFiles>();
@@ -20,14 +26,7 @@ public static class DependencyInjection
 
         //TODO: Check lifetime of services. They might be singleton or scoped.
         services.AddTransient<GdViewer>();
-        // Add LicenseManager
-        services.AddTransient(provider =>
-        {
-            var options = provider.GetRequiredService<IOptions<WorkerOptions>>().Value;
-            var licenseManager = new LicenseManager();
-            licenseManager.RegisterKEY(options.GdPictureLicenseKey);
-            return licenseManager;
-        });
+        services.AddSingleton<LicenseManagerFactory>();
         services.AddTransient<AnnotationManager>();
 
         return services;

EnvelopeGenerator.ServiceHost/Jobs/FinalizeDocument/PDFBurner.cs

@@ -4,6 +4,7 @@ using EnvelopeGenerator.Domain.Entities;
 using EnvelopeGenerator.Infrastructure;
 using EnvelopeGenerator.PdfEditor;
 using EnvelopeGenerator.ServiceHost.Exceptions;
+using EnvelopeGenerator.ServiceHost.Jobs;
 using GdPicture14;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Options;
@@ -11,16 +12,7 @@ using Newtonsoft.Json;
 
 namespace EnvelopeGenerator.ServiceHost.Jobs.FinalizeDocument;
 
-//TODO: check if licence manager is needed as a dependency to 
-/// <summary>
-/// 
-/// </summary>
-/// <param name="workerOptions"></param>
-/// <param name="context2"></param>
-/// <param name="logger2"></param>
-/// <param name="licenseManager"></param>
-/// <param name="annotationManager2"></param>
-public class PDFBurner(IOptions<WorkerOptions> workerOptions, EGDbContext context, ILogger<PDFBurner> logger, LicenseManager licenseManager, AnnotationManager manager)
+public class PDFBurner(IOptions<WorkerOptions> workerOptions, EGDbContext context, ILogger<PDFBurner> logger, LicenseManagerFactory licenseManagerFactory, AnnotationManager manager)
 {
     private readonly WorkerOptions.PDFBurnerOptions _options = workerOptions.Value.PdfBurner;
     

EnvelopeGenerator.ServiceHost/Jobs/FinalizeDocument/PDFMerger.cs

@@ -1,4 +1,5 @@
 using EnvelopeGenerator.ServiceHost.Exceptions;
+using EnvelopeGenerator.ServiceHost.Jobs;
 using GdPicture14;
 using Microsoft.Extensions.Options;
 
@@ -7,16 +8,16 @@ namespace EnvelopeGenerator.ServiceHost.Jobs.FinalizeDocument;
 public class PDFMerger
 {
     private readonly AnnotationManager _manager;
-    private readonly LicenseManager _licenseManager;
+    private readonly LicenseManagerFactory _licenseManagerFactory;
 
     private const bool AllowRasterization = true;
     private const bool AllowVectorization = true;
 
     private readonly PdfConversionConformance _pdfaConformanceLevel = PdfConversionConformance.PDF_A_1b;
 
-    public PDFMerger(LicenseManager licenseManager, AnnotationManager annotationManager)
+    public PDFMerger(LicenseManagerFactory licenseManagerFactory, AnnotationManager annotationManager)
     {
-        _licenseManager = licenseManager;
+        _licenseManagerFactory = licenseManagerFactory;
         _manager = annotationManager;
     }
 

EnvelopeGenerator.ServiceHost/Jobs/FinalizeDocumentJob.cs

@@ -38,7 +38,6 @@ public class FinalizeDocumentJob(IOptions<WorkerOptions> options, ILogger<Finali
 
     public async Task ExecuteAsync(IEnumerable<EnvelopeDto> envelopes, CancellationToken cancel = default)
     {
-        var gdPictureKey = _options.GdPictureLicenseKey;
         tempFiles.Create();
         var jobId = typeof(FinalizeDocumentJob).FullName;
 

EnvelopeGenerator.ServiceHost/Jobs/JobStateManager.cs

@@ -0,0 +1,19 @@
+using AngleSharp.Common;
+using System.Collections.Concurrent;
+
+namespace EnvelopeGenerator.ServiceHost.Jobs;
+
+public class JobStateManager(Dictionary<string, State>? initialState = null)
+{
+    private readonly ConcurrentDictionary<Type, State> _states = new();
+
+    public State GetState<TJob>() => _states.GetOrAdd(typeof(TJob), type => initialState?.GetOrDefault(type.Name, State.Stopped) ?? State.Stopped);
+
+    public State SetState<TJob>(State state) => _states[typeof(TJob)] = state;
+}
+
+public enum State
+{
+    Running,
+    Stopped
+}

EnvelopeGenerator.ServiceHost/Jobs/LicenseManagerFactory.cs

@@ -0,0 +1,39 @@
+using EnvelopeGenerator.Application.ThirdPartyModules.Queries;
+using GdPicture14;
+using MediatR;
+using Microsoft.Extensions.Caching.Memory;
+
+namespace EnvelopeGenerator.ServiceHost.Jobs;
+
+public class LicenseManagerFactory
+{
+    private static readonly string _cacheKey = Guid.NewGuid().ToString();
+    private readonly IServiceScopeFactory scopeFactory;
+    private readonly IMemoryCache cache;
+
+    public LicenseManagerFactory(IServiceScopeFactory scopeFactory, IMemoryCache cache)
+    {
+        this.scopeFactory = scopeFactory;
+        this.cache = cache;
+        _ = CreateAsync(); // Preload the license key into the cache
+    }
+
+    public async Task<LicenseManager> CreateAsync(CancellationToken cancellationToken = default)
+    {
+        var key = await GetLicenseKeyAsync(cancellationToken);
+        var licenseManager = new LicenseManager();
+        licenseManager.RegisterKEY(key);
+        return licenseManager;
+    }
+
+    public async Task<string> GetLicenseKeyAsync(CancellationToken cancellationToken = default)
+    {
+        return await cache.GetOrCreateAsync(_cacheKey, async entry =>
+        {
+            entry.Priority = CacheItemPriority.NeverRemove;
+            using var scope = scopeFactory.CreateScope();
+            var mediator = scope.ServiceProvider.GetRequiredService<IMediator>();
+            return await mediator.Send(new ReadThirdPartyModuleLicenseQuery { Name = "GdPicture", Active =true }, cancellationToken);
+        }) ?? throw new InvalidOperationException("License key could not be retrieved.");
+    }
+}

EnvelopeGenerator.ServiceHost/Jobs/WorkerOptions.cs

@@ -1,11 +1,22 @@
-using EnvelopeGenerator.ServiceHost.Jobs.FinalizeDocument;
-using System.Drawing;
-
 namespace EnvelopeGenerator.ServiceHost.Jobs;
 
 public class WorkerOptions
 {
-    public string GdPictureLicenseKey { get; set; } = null!;
+    private int _delayMilliseconds = 1000;
+
+    public int DelayMilliseconds
+    {
+        get => _delayMilliseconds;
+        set
+        {
+            if (value < 1)
+                throw new ArgumentOutOfRangeException(nameof(value), "Delay must be at least 1 millisecond.");
+
+            _delayMilliseconds = value;
+        }
+    }
+
+    public Dictionary<string, State> InitialJobState { get; set; } = [];
 
     public PDFBurnerOptions PdfBurner { get; set; } = new();
 

EnvelopeGenerator.ServiceHost/Worker.cs

@@ -1,17 +1,20 @@
 using EnvelopeGenerator.ServiceHost.Jobs;
+using Microsoft.Extensions.Options;
 
 namespace EnvelopeGenerator.ServiceHost;
 
 public class Worker : BackgroundService
 {
     private readonly ILogger<Worker> _logger;
-    private readonly int _delayMilliseconds;
+    private readonly WorkerOptions _options;
+    private readonly JobStateManager _jobStateManager;
     private readonly IServiceScopeFactory _scopeFactory;
 
-    public Worker(ILogger<Worker> logger, IConfiguration configuration, IServiceScopeFactory scopeFactory)
+    public Worker(ILogger<Worker> logger, IOptions<WorkerOptions> options, JobStateManager jobStateManager, IServiceScopeFactory scopeFactory)
     {
         _logger = logger;
-        _delayMilliseconds = Math.Max(1, configuration.GetValue("Worker:DelayMilliseconds", 1000));
+        _options = options.Value;
+        _jobStateManager = jobStateManager;
         _scopeFactory = scopeFactory;
     }
 
@@ -24,11 +27,14 @@ public class Worker : BackgroundService
                 _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
             }
 
-            using var scope = _scopeFactory.CreateScope();
-            var finalizeDocumentJob = scope.ServiceProvider.GetRequiredService<FinalizeDocumentJob>();
-            await finalizeDocumentJob.ExecuteAsync(stoppingToken);
+            if (_jobStateManager.GetState<FinalizeDocumentJob>() == State.Running)
+            {
+                using var scope = _scopeFactory.CreateScope();
+                var finalizeDocumentJob = scope.ServiceProvider.GetRequiredService<FinalizeDocumentJob>();
+                await finalizeDocumentJob.ExecuteAsync(stoppingToken);
+            }
 
-            await Task.Delay(_delayMilliseconds, stoppingToken);
+            await Task.Delay(_options.DelayMilliseconds, stoppingToken);
         }
     }
-}
+}

EnvelopeGenerator.ServiceHost/appsettings.Development.json

@@ -2,7 +2,7 @@
   "Logging": {
     "LogLevel": {
       "Default": "Information",
-      "Microsoft.AspNetCore": "Warning"
+      "Microsoft.AspNetCore": "Information"
     }
   }
 }

EnvelopeGenerator.ServiceHost/appsettings.json

@@ -6,7 +6,11 @@
     }
   },
   "Worker": {
-    "DelayMilliseconds": 1000
+    "DelayMilliseconds": 1000,
+    // InitialJobState: State values are 0 = Running, 1 = Stopped. Defaults to 1 (Stopped) if not specified.
+    "InitialJobState": {
+      "FinalizeDocumentJob": 0
+    }
   },
   "AllowedHosts": "*",
   "SupportedCultures": [ "de-DE", "en-US" ],