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.API/Controllers/EnvelopeController.cs

@@ -71,6 +71,7 @@ public class EnvelopeController : ControllerBase
     [HttpGet("doc-result")]
     public async Task<IActionResult> GetDocResultAsync([FromQuery] ReadEnvelopeQuery query, [FromQuery] bool view = false)
     {
+        query.IncludeDocResult = true;
         var envelopes = await _mediator.Send(query.Authorize(User.GetId()));
         var envelope = envelopes.FirstOrDefault();
 

EnvelopeGenerator.Application/Common/CacheKey.cs

@@ -0,0 +1,13 @@
+namespace EnvelopeGenerator.Application.Common;
+
+// TODO: merge other cache keys here as well, e.g. for templates, etc.
+/// <summary>
+/// 
+/// </summary>
+public static class CacheKey
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public static readonly Guid DefaultConfig = Guid.NewGuid();
+}

EnvelopeGenerator.Application/Common/Dto/ConfigDto.cs

@@ -8,6 +8,11 @@ namespace EnvelopeGenerator.Application.Common.Dto;
 [ApiExplorerSettings(IgnoreApi = true)]
 public class ConfigDto
 {
+    /// <summary>
+    /// Gets or sets the default document path.
+    /// </summary>
+    public string? DocumentPath { get; set; }
+
     /// <summary>
     /// Gets or sets the sending profile identifier.
     /// </summary>
@@ -26,5 +31,30 @@ public class ConfigDto
     /// <summary>
     /// Gets or sets the path where exports will be saved.
     /// </summary>
-    public string? ExportPath { get; set; }
+    public string ExportPath { get; set; } = null!;
+
+    /// <summary>
+    /// Gets or sets the creation timestamp.
+    /// </summary>
+    public DateTime AddedWhen { get; set; }
+
+    /// <summary>
+    /// Gets or sets the last update timestamp.
+    /// </summary>
+    public DateTime? ChangedWhen { get; set; }
+
+    /// <summary>
+    /// Gets or sets the legacy tinyint GUID field.
+    /// </summary>
+    public byte Guid { get; set; }
+
+    /// <summary>
+    /// Gets or sets whether default TFA is enabled.
+    /// </summary>
+    public bool DefTfaEnabled { get; set; }
+
+    /// <summary>
+    /// Gets or sets whether default TFA uses phone.
+    /// </summary>
+    public bool DefTfaWithPhone { get; set; }
 }

EnvelopeGenerator.Application/Common/Dto/EnvelopeDto.cs

@@ -1,5 +1,6 @@
 using DigitalData.EmailProfilerDispatcher.Abstraction.Attributes;
 using DigitalData.UserManager.Application.DTOs.User;
+using EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiver;
 using EnvelopeGenerator.Domain.Constants;
 using EnvelopeGenerator.Domain.Entities;
 using EnvelopeGenerator.Domain.Interfaces;
@@ -44,6 +45,16 @@ public record EnvelopeDto : IEnvelope
     [TemplatePlaceholder("[MESSAGE]")]
     public string Message { get; set; } = string.Empty;
 
+    /// <summary>
+    /// 
+    /// </summary>
+    public DateTime? ExpiresWhen { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public DateTime? ExpiresWarningWhen { get; set; }
+
     /// <summary>
     /// 
     /// </summary>
@@ -60,6 +71,11 @@ public record EnvelopeDto : IEnvelope
     [TemplatePlaceholder("[DOCUMENT_TITLE]")]
     public string Title { get; set; } = string.Empty;
 
+    /// <summary>
+    /// Default value is string.Empty
+    /// </summary>
+    public string? Comment { get; set; }
+
     /// <summary>
     /// 
     /// </summary>
@@ -70,6 +86,21 @@ public record EnvelopeDto : IEnvelope
     /// </summary>
     public string Language { get; set; } = "de-DE";
 
+    /// <summary>
+    /// 
+    /// </summary>
+    public bool SendReminderEmails { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public int? FirstReminderDays { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public int? ReminderIntervalDays { get; set; }
+
     /// <summary>
     /// 
     /// </summary>
@@ -90,6 +121,26 @@ public record EnvelopeDto : IEnvelope
     /// </summary>
     public bool UseAccessCode { get; set; } = true;
 
+    /// <summary>
+    /// 
+    /// </summary>
+    public int? FinalEmailToCreator { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public int? FinalEmailToReceivers { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public int? ExpiresWhenDays { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public int? ExpiresWarningWhenDays { get; set; }
+
     /// <summary>
     /// 
     /// </summary>
@@ -124,4 +175,9 @@ public record EnvelopeDto : IEnvelope
     /// 
     /// </summary>
     public IEnumerable<DocumentDto>? Documents { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public IEnumerable<EnvelopeReceiverDto>? EnvelopeReceivers { get; set; }
 }

EnvelopeGenerator.Application/Common/Query/EnvelopeQueryBase.cs

@@ -14,4 +14,10 @@ public record EnvelopeQueryBase
     /// Die universell eindeutige Kennung des Umschlags.
     /// </summary>
     public virtual string? Uuid { get; set; }
+
+    /// <summary>
+    /// Wenn gesetzt, wird das DocResult-Feld in der Abfrage einbezogen.
+    /// Standardmäßig wird DocResult nicht geladen, um große Binärdaten zu vermeiden.
+    /// </summary>
+    public bool IncludeDocResult { get; set; } = false;
 }

EnvelopeGenerator.Application/Configuration/Queries/ReadDefaultConfigQuery.cs

@@ -0,0 +1,69 @@
+using AutoMapper;
+using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.Core.Exceptions;
+using EnvelopeGenerator.Application.Common;
+using EnvelopeGenerator.Application.Common.Dto;
+using EnvelopeGenerator.Domain.Entities;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Caching.Distributed;
+using Microsoft.Extensions.Caching.Memory;
+
+namespace EnvelopeGenerator.Application.Configuration.Queries;
+
+/// <summary>
+/// 
+/// </summary>
+public record ReadDefaultConfigQuery : IRequest<ConfigDto>
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public bool EnforceSingleResult { get; init; }
+}
+
+/// <summary>
+/// 
+/// </summary>
+public class ReadDefaultConfigQueryHandler : IRequestHandler<ReadDefaultConfigQuery, ConfigDto>
+{
+    private readonly IRepository<Config> _repo;
+
+    private readonly IMapper _mapper;
+
+    private readonly IMemoryCache _cache;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="repo"></param>
+    /// <param name="mapper"></param>
+    /// <param name="cache"></param>
+    public ReadDefaultConfigQueryHandler(IRepository<Config> repo, IMapper mapper, IMemoryCache cache)
+    {
+        _repo = repo;
+        _mapper = mapper;
+        _cache = cache;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancel"></param>
+    /// <returns></returns>
+    /// <exception cref="InvalidOperationException"></exception>
+    public async Task<ConfigDto> Handle(ReadDefaultConfigQuery request, CancellationToken cancel)
+    {
+        var config = await _cache.GetOrCreateAsync(CacheKey.DefaultConfig, entry =>
+        {
+            entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(30);
+            return request.EnforceSingleResult
+            ? _repo.Query.SingleOrDefaultAsync(cancel)
+            : _repo.Query.FirstOrDefaultAsync(cancel)
+            ?? throw new NotFoundException("Default configuration could not be found. Ensure at least one configuration record exists in the database.");
+        });
+
+        return _mapper.Map<ConfigDto>(config);
+    }
+}

EnvelopeGenerator.Application/EnvelopeGenerator.Application.csproj

@@ -41,7 +41,7 @@
 	</ItemGroup>
 
 	<ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
-		<PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.5" />
+		<PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.6" />
 	</ItemGroup>
 
 	<ItemGroup>
@@ -78,26 +78,29 @@
 		</EmbeddedResource>
 	</ItemGroup>
 
-	<ItemGroup Condition="'$(TargetFramework)' == 'net7.0'">
+  <ItemGroup Condition="'$(TargetFramework)' == 'net7.0'">
-	  <PackageReference Include="AutoMapper" Version="13.0.1" />
+	<PackageReference Include="AutoMapper" Version="13.0.1" />
-	  <PackageReference Include="Microsoft.Data.SqlClient" Version="5.2.2" />
+	<PackageReference Include="Microsoft.Data.SqlClient" Version="5.2.2" />
-	  <PackageReference Include="CommandDotNet">
+	<PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="7.0.20" />
+	<PackageReference Include="CommandDotNet">
 		<Version>7.0.5</Version>
-	  </PackageReference>
+	</PackageReference>
-	</ItemGroup>
+  </ItemGroup>
 
-	<ItemGroup Condition="'$(TargetFramework)' == 'net8.0'">
+  <ItemGroup Condition="'$(TargetFramework)' == 'net8.0'">
-	  <PackageReference Include="AutoMapper" Version="14.0.0" />
+	<PackageReference Include="AutoMapper" Version="14.0.0" />
-	  <PackageReference Include="CommandDotNet">
+	<PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="8.0.17" />
-	    <Version>8.1.1</Version>
+	<PackageReference Include="CommandDotNet">
-	  </PackageReference>
+	  <Version>8.1.1</Version>
-	</ItemGroup>
+	</PackageReference>
+  </ItemGroup>
 
-	<ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
+  <ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
-	  <PackageReference Include="AutoMapper" Version="14.0.0" />
+	<PackageReference Include="AutoMapper" Version="14.0.0" />
-	  <PackageReference Include="CommandDotNet">
+	<PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="9.0.6" />
-	    <Version>8.1.1</Version>
+	<PackageReference Include="CommandDotNet">
-	  </PackageReference>
+	  <Version>8.1.1</Version>
-	</ItemGroup>
+	</PackageReference>
+  </ItemGroup>
 
 </Project>

EnvelopeGenerator.Application/Envelopes/Queries/ReadEnvelopeQuery.cs

@@ -24,6 +24,12 @@ public record ReadEnvelopeQuery : EnvelopeQueryBase, IRequest<IEnumerable<Envelo
     /// </summary>
     public int? UserId { get; init; }
 
+    /// <summary>
+    /// Optionaler Zeitfilter in Minuten; wenn gesetzt, werden nur Umschläge zurückgegeben,
+    /// deren letzte Änderung mindestens diese Anzahl an Minuten zurückliegt.
+    /// </summary>
+    public int? MinMinutesSinceLastChange { get; init; }
+
     /// <summary>
     /// Setzt den Benutzerkontext für die Abfrage.
     /// </summary>
@@ -132,6 +138,12 @@ public class ReadEnvelopeQueryHandler : IRequestHandler<ReadEnvelopeQuery, IEnum
                 query = query.Where(e => !status.Ignore.Contains(e.Status));
         }
 
+        if (request.MinMinutesSinceLastChange is int minMinutesSinceLastChange)
+        {
+            query = query.Where(e => e.ChangedWhen.HasValue
+                && EF.Functions.DateDiffMinute(e.ChangedWhen.Value, DateTime.Now) >= minMinutesSinceLastChange);
+        }
+
         var envelopes = await query
             .Include(e => e.Documents)
             .ToListAsync(cancel);

EnvelopeGenerator.Application/Envelopes/Queries/ReadSingleEnvelopeDocResultQuery.cs

@@ -0,0 +1,48 @@
+using MediatR;
+using EnvelopeGenerator.Application.Common.Dto;
+using DigitalData.Core.Exceptions;
+
+namespace EnvelopeGenerator.Application.Envelopes.Queries;
+
+/// <summary>
+/// Repräsentiert eine Abfrage für Umschläge.
+/// </summary>
+public record ReadSingleEnvelopeDocResultQuery() : IRequest<byte[]>
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public ReadSingleEnvelopeQuery Envelope { get; set; } = null!;
+}
+
+/// <summary>
+/// Verarbeitet <see cref="ReadEnvelopeQuery"/> und liefert passende <see cref="EnvelopeDto"/>-Ergebnisse.
+/// </summary>
+public class ReadSingleEnvelopeDocResultQueryHandler : IRequestHandler<ReadSingleEnvelopeDocResultQuery, byte[]>
+{
+    private readonly IMediator _mediator;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="mediator"></param>
+    public ReadSingleEnvelopeDocResultQueryHandler(IMediator mediator)
+    {
+        _mediator = mediator;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    public async Task<byte[]> Handle(ReadSingleEnvelopeDocResultQuery request, CancellationToken cancellationToken)
+    {
+        request.Envelope.IncludeDocResult = true;
+        var result = await _mediator.Send(request.Envelope, cancellationToken);
+        return result.DocResult is byte[] docResult && docResult.Length > 0 
+            ? docResult 
+            : throw new NotFoundException($"Document for Envelope with ID {request.Envelope.Id} not found");
+    }
+}

EnvelopeGenerator.Application/Envelopes/Queries/ReadSingleEnvelopeQuery.cs

@@ -0,0 +1,78 @@
+using MediatR;
+using EnvelopeGenerator.Application.Common.Query;
+using EnvelopeGenerator.Application.Common.Dto;
+using AutoMapper;
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Domain.Entities;
+using Microsoft.EntityFrameworkCore;
+using DigitalData.Core.Exceptions;
+
+namespace EnvelopeGenerator.Application.Envelopes.Queries;
+
+/// <summary>
+/// Repräsentiert eine Abfrage für einen einzelnen Umschlag.
+/// </summary>
+public record ReadSingleEnvelopeQuery : EnvelopeQueryBase, IRequest<EnvelopeDto>
+{
+    /// <summary>
+    /// Optionaler Benutzerfilter; wenn gesetzt, werden nur Umschläge des Benutzers geladen.
+    /// </summary>
+    public int? UserId { get; init; }
+
+    /// <summary>
+    /// Setzt den Benutzerkontext für die Abfrage.
+    /// </summary>
+    public ReadSingleEnvelopeQuery Authorize(int userId) => this with { UserId = userId };
+}
+
+/// <summary>
+/// Verarbeitet <see cref="ReadSingleEnvelopeQuery"/> und liefert ein einzelnes <see cref="EnvelopeDto"/>-Ergebnis.
+/// </summary>
+public class ReadSingleEnvelopeQueryHandler : IRequestHandler<ReadSingleEnvelopeQuery, EnvelopeDto>
+{
+    private readonly IRepository<Envelope> _repository;
+    private readonly IMapper _mapper;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="repository"></param>
+    /// <param name="mapper"></param>
+    public ReadSingleEnvelopeQueryHandler(IRepository<Envelope> repository, IMapper mapper)
+    {
+        _repository = repository;
+        _mapper = mapper;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancel"></param>
+    /// <returns></returns>
+    public async Task<EnvelopeDto> Handle(ReadSingleEnvelopeQuery request, CancellationToken cancel)
+    {
+        var query = _repository.Query;
+
+        if (request.UserId is int userId)
+            query = query.Where(e => e.UserId == userId);
+
+        if (request.Id is int id)
+            query = query.Where(e => e.Id == id);
+
+        if (request.Uuid is string uuid)
+            query = query.Where(e => e.Uuid == uuid);
+        
+        var envelopes = await query
+            .Include(e => e.Documents)
+            .Take(2)
+            .ToListAsync(cancel);
+
+        if (envelopes.Count > 1)
+            throw new BadRequestException($"Multiple envelopes found for the given criteria: Id={request.Id}, Uuid={request.Uuid}, UserId={request.UserId}");
+
+        return envelopes.SingleOrDefault() is Envelope envelope
+            ? _mapper.Map<EnvelopeDto>(envelope)
+            : throw new NotFoundException($"Envelope with Id={request.Id}, Uuid={request.Uuid} not found");
+    }
+}

EnvelopeGenerator.Application/Services/ConfigService.cs

@@ -7,6 +7,7 @@ using Microsoft.Extensions.Logging;
 using EnvelopeGenerator.Application.Common.Dto;
 using EnvelopeGenerator.Application.Common.Interfaces.Repositories;
 using EnvelopeGenerator.Application.Common.Interfaces.Services;
+using EnvelopeGenerator.Application.Common;
 
 namespace EnvelopeGenerator.Application.Services;
 
@@ -16,8 +17,6 @@ namespace EnvelopeGenerator.Application.Services;
 [Obsolete("Use MediatR")]
 public class ConfigService : ReadService<IConfigRepository, ConfigDto, Config, int>, IConfigService
 {
-	private static readonly Guid DefaultConfigCacheId = Guid.NewGuid();
-
 	private readonly IMemoryCache _cache;
 
     private readonly ILogger<ConfigService> _logger;
@@ -62,7 +61,7 @@ public class ConfigService : ReadService<IConfigRepository, ConfigDto, Config, i
 	/// </exception>
 	public async Task<ConfigDto> ReadDefaultAsync()
     {
-        var config = await _cache.GetOrCreateAsync(DefaultConfigCacheId, _ => ReadFirstAsync().ThenAsync(
+        var config = await _cache.GetOrCreateAsync(CacheKey.DefaultConfig, _ => ReadFirstAsync().ThenAsync(
             Success: config => config,
             Fail: (mssg, ntc) =>
             {

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/Config.cs

@@ -1,11 +1,17 @@
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
+#if NETFRAMEWORK
+using System;
+#endif
 
 namespace EnvelopeGenerator.Domain.Entities
 {
     [Table("TBSIG_CONFIG", Schema = "dbo")]
     public class Config
     {
+        [Column("DOCUMENT_PATH", TypeName = "nvarchar(256)")]
+        public string DocumentPath { get; set; }
+
         [Column("SENDING_PROFILE", TypeName = "int")]
         [Required]
         public int SendingProfile { get; set; }
@@ -19,5 +25,24 @@ namespace EnvelopeGenerator.Domain.Entities
 
         [Column("EXPORT_PATH", TypeName = "nvarchar(256)")]
         public string ExportPath { get; set; }
+
+        [Column("ADDED_WHEN", TypeName = "datetime")]
+        [Required]
+        public DateTime AddedWhen { get; set; }
+
+        [Column("CHANGED_WHEN", TypeName = "datetime")]
+        public DateTime? ChangedWhen { get; set; }
+
+        [Column("GUID", TypeName = "tinyint")]
+        [Required]
+        public byte Guid { get; set; }
+
+        [Column("DEF_TFA_ENABLED", TypeName = "bit")]
+        [Required]
+        public bool DefTfaEnabled { get; set; }
+
+        [Column("DEF_TFA_WITH_PHONE", TypeName = "bit")]
+        [Required]
+        public bool DefTfaWithPhone { get; set; }
     }
 }

EnvelopeGenerator.Domain/Entities/Envelope.cs

@@ -76,11 +76,14 @@ namespace EnvelopeGenerator.Domain.Entities
 #if nullable
         ?
 #endif
-            Title
+            Title { get; set; }
-        { get; set; }
 
         [Column("COMMENT", TypeName = "nvarchar(128)")]
-        public string Comment { get; set; }
+        public string
+#if nullable
+        ?
+#endif
+            Comment { get; set; }
 
         [Column("CONTRACT_TYPE")]
         public int? ContractType { get; set; }
@@ -137,7 +140,9 @@ namespace EnvelopeGenerator.Domain.Entities
             = false;
 #endif
 
+#if NETFRAMEWORK
         [NotMapped]
+#endif
         [Column("DOC_RESULT")]
         public byte[]
 #if nullable
@@ -151,8 +156,7 @@ namespace EnvelopeGenerator.Domain.Entities
 #if nullable
         ?
 #endif
-            Type
+            Type { get; set; }
-        { get; set; }
 
 #if NETFRAMEWORK
         [NotMapped]
@@ -166,22 +170,26 @@ namespace EnvelopeGenerator.Domain.Entities
 #if nullable
         ?
 #endif
-            Documents
+            Documents { get; set; }
-        { get; set; }
+
+        [NotMapped]
+        public Document
+#if nullable
+        ?
+#endif
+            DefaultDocument => Documents?.FirstOrDefault();
 
         public List<History>
 #if nullable
         ?
 #endif
-            Histories
+            Histories { get; set; }
-        { get; set; }
 
         public List<EnvelopeReceiver>
 #if nullable
         ?
 #endif
-            EnvelopeReceivers
+            EnvelopeReceivers { get; set; }
-        { get; set; }
 
         //#if NETFRAMEWORK
         /// <summary>

EnvelopeGenerator.Domain/Entities/EnvelopeReport.cs

@@ -0,0 +1,36 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace EnvelopeGenerator.Domain.Entities
+{
+    [Table("VWSIG_ENVELOPE_REPORT", Schema = "dbo")]
+    public class EnvelopeReport
+    {
+        [Column("ENVELOPE_ID", TypeName = "int")]
+        [Required]
+        public int EnvelopeId { get; set; }
+
+        [Column("HEAD_UUID", TypeName = "nvarchar(36)")]
+        [Required]
+        public string HeadUuid { get; set; }
+
+        [Column("HEAD_TITLE", TypeName = "nvarchar(128)")]
+        public string HeadTitle { get; set; }
+
+        [Column("HEAD_MESSAGE", TypeName = "nvarchar(max)")]
+        [Required]
+        public string HeadMessage { get; set; }
+
+        [Column("POS_STATUS", TypeName = "int")]
+        [Required]
+        public int PosStatus { get; set; }
+
+        [Column("POS_WHEN", TypeName = "datetime")]
+        public DateTime? PosWhen { get; set; }
+
+        [Column("POS_WHO", TypeName = "nvarchar(128)")]
+        [Required]
+        public string PosWho { get; set; }
+    }
+}

EnvelopeGenerator.Domain/Entities/Signature.cs

@@ -4,6 +4,9 @@ using System.ComponentModel;
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
 using EnvelopeGenerator.Domain.Interfaces.Auditing;
+#if NET
+using System.Text.Json.Serialization;
+#endif
 #if NETFRAMEWORK
 using System.Collections.Generic;
 #endif
@@ -109,22 +112,25 @@ namespace EnvelopeGenerator.Domain.Entities
 #if nullable
         ?
 #endif
-            Receiver
+            Receiver { get; set; }
-        { get; set; }
 
         public virtual IEnumerable<ElementAnnotation>
 #if nullable
         ?
 #endif
-            Annotations
+            Annotations { get; set; }
-        { get; set; }
 
-#if NETFRAMEWORK
+#if NET
+        [JsonIgnore]
+#endif
         [NotMapped]
         public double Top => Math.Round(Y, 5);
 
+
+#if NET
+        [JsonIgnore]
+#endif
         [NotMapped]
         public double Left => Math.Round(X, 5);
-#endif
     }
 }

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

@@ -79,6 +79,10 @@ public abstract class EGDbContextBase : DbContext
 
     public DbSet<ClientUser> ClientUsers { get; set; }
 
+    public DbSet<EnvelopeReport> EnvelopeReports { get; set; }
+
+    public DbSet<ThirdPartyModule> ThirdPartyModules { get; set; }
+
     private readonly DbTriggerParams _triggers;
 
     private readonly ILogger
@@ -200,6 +204,10 @@ public abstract class EGDbContextBase : DbContext
             .HasForeignKey(annot => annot.ElementId);
         #endregion
 
+        #region EnvelopeReport
+        modelBuilder.Entity<EnvelopeReport>().HasNoKey();
+        #endregion
+
         #region Trigger
         // Configure entities to handle database triggers
         void AddTrigger<T>() where T : class => _triggers

EnvelopeGenerator.ServiceHost/Controllers/DocResultController.cs

@@ -0,0 +1,21 @@
+using EnvelopeGenerator.Application.Envelopes.Queries;
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.ServiceHost.Controllers;
+
+[Route("api/[controller]")]
+[ApiController]
+public class DocResultController(IMediator mediator) : ControllerBase
+{
+    [HttpGet]
+    public async Task<IActionResult> GetAsync([FromQuery] ReadSingleEnvelopeDocResultQuery query, [FromQuery] bool download = false, CancellationToken cancel = default)
+    {
+        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/FinalizeDocumentController.cs

@@ -0,0 +1,29 @@
+using EnvelopeGenerator.Application.Envelopes.Queries;
+using EnvelopeGenerator.ServiceHost.Jobs;
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.ServiceHost.Controllers;
+
+/// <summary>
+/// 
+/// </summary>
+/// <param name="mediator"></param>
+/// <param name="job"></param>
+[Route("api/[controller]")]
+[ApiController]
+public class FinalizeDocumentController(IMediator mediator, FinalizeDocumentJob job) : ControllerBase
+{
+    [HttpGet]
+    public async Task<IActionResult> FinalizeEnvelopeDocument([FromQuery] ReadSingleEnvelopeQuery query, [FromQuery] bool forceRegenerate = false, CancellationToken cancel = default)
+    {
+        var envelope = await mediator.Send(query, cancel);
+
+        // TODO: migrate forceRegenerate input to FinalizeDocumentJob as property and remove this check from controller
+        if (envelope.DocResult is null || forceRegenerate)
+            await job.ExecuteAsync(envelope, cancel);
+
+        var docResult = await mediator.Send(new ReadSingleEnvelopeDocResultQuery() { Envelope = query }, cancel);
+        return File(docResult, "application/pdf", $"envelope_{query.Uuid}.pdf");
+    }
+}

EnvelopeGenerator.ServiceHost/Controllers/WorkerController.cs

@@ -0,0 +1,21 @@
+using EnvelopeGenerator.ServiceHost.Jobs;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.ServiceHost.Controllers;
+
+[Route("api/[controller]")]
+[ApiController]
+public class WorkerController(JobStateManager jobStateManager) : ControllerBase
+{
+    private readonly JobStateManager _jobStateManager = jobStateManager;
+
+    [HttpGet(nameof(FinalizeDocumentJob))]
+    public IActionResult GetStateOfFinalizeDocumentJob() => Ok(_jobStateManager.GetState<FinalizeDocumentJob>());
+
+    [HttpPost(nameof(FinalizeDocumentJob))]
+    public IActionResult SetStateOfFinalizeDocumentJob([FromQuery] State state)
+    {
+        _jobStateManager.SetState<FinalizeDocumentJob>(state);
+        return Ok();
+    }
+}

EnvelopeGenerator.ServiceHost/EnvelopeGenerator.ServiceHost.csproj

@@ -0,0 +1,46 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0-windows</TargetFramework>
+    <UseWindowsForms>true</UseWindowsForms>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="DigitalData.Core.API" Version="2.2.1" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.6.2" />
+    <PackageReference Include="GdPicture" Version="14.3.3" />
+    <PackageReference Include="Microsoft.Data.SqlClient" Version="6.1.4" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.17" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="8.0.17" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+    <PackageReference Include="Quartz" Version="3.8.0" />
+    <PackageReference Include="System.Collections.Immutable" Version="8.0.0" />
+    <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.Hosting.WindowsServices" Version="8.0.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\EnvelopeGenerator.Application\EnvelopeGenerator.Application.csproj" />
+    <ProjectReference Include="..\EnvelopeGenerator.Domain\EnvelopeGenerator.Domain.csproj" />
+    <ProjectReference Include="..\EnvelopeGenerator.Infrastructure\EnvelopeGenerator.Infrastructure.csproj" />
+    <ProjectReference Include="..\EnvelopeGenerator.PdfEditor\EnvelopeGenerator.PdfEditor.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Compile Update="Jobs\FinalizeDocument\rptEnvelopeHistory.cs">
+      <SubType>Component</SubType>
+    </Compile>
+    <Compile Update="Jobs\FinalizeDocument\rptEnvelopeHistory.Designer.cs">
+      <DependentUpon>rptEnvelopeHistory.cs</DependentUpon>
+    </Compile>
+    <EmbeddedResource Update="Jobs\FinalizeDocument\rptEnvelopeHistory.resx">
+      <DependentUpon>rptEnvelopeHistory.cs</DependentUpon>
+    </EmbeddedResource>
+  </ItemGroup>
+
+</Project>

EnvelopeGenerator.ServiceHost/Exceptions/BurnAnnotationException.cs

@@ -0,0 +1,12 @@
+namespace EnvelopeGenerator.ServiceHost.Exceptions;
+
+public class BurnAnnotationException : ApplicationException
+{
+    public BurnAnnotationException(string message) : base(message)
+    {
+    }
+
+    public BurnAnnotationException(string message, Exception innerException) : base(message, innerException)
+    {
+    }
+}

EnvelopeGenerator.ServiceHost/Exceptions/CreateReportException.cs

@@ -0,0 +1,12 @@
+namespace EnvelopeGenerator.ServiceHost.Exceptions;
+
+public class CreateReportException : ApplicationException
+{
+    public CreateReportException(string message) : base(message)
+    {
+    }
+
+    public CreateReportException(string message, Exception innerException) : base(message, innerException)
+    {
+    }
+}

EnvelopeGenerator.ServiceHost/Exceptions/ExportDocumentException.cs

@@ -0,0 +1,12 @@
+namespace EnvelopeGenerator.ServiceHost.Exceptions;
+
+public class ExportDocumentException : ApplicationException
+{
+    public ExportDocumentException(string message) : base(message)
+    {
+    }
+
+    public ExportDocumentException(string message, Exception innerException) : base(message, innerException)
+    {
+    }
+}

EnvelopeGenerator.ServiceHost/Exceptions/MergeDocumentException.cs

@@ -0,0 +1,12 @@
+namespace EnvelopeGenerator.ServiceHost.Exceptions;
+
+public class MergeDocumentException : ApplicationException
+{
+    public MergeDocumentException(string message) : base(message)
+    {
+    }
+
+    public MergeDocumentException(string message, Exception innerException) : base(message, innerException)
+    {
+    }
+}

EnvelopeGenerator.ServiceHost/Extensions/DataRowExtensions.cs

@@ -0,0 +1,27 @@
+using System.Data;
+
+namespace EnvelopeGenerator.ServiceHost.Extensions;
+
+public static class DataRowExtensions
+{
+    public static T ItemEx<T>(this DataRow row, string columnName, T defaultValue)
+    {
+        if (!row.Table.Columns.Contains(columnName))
+        {
+            return defaultValue;
+        }
+
+        var value = row[columnName];
+        if (value is DBNull or null)
+        {
+            return defaultValue;
+        }
+
+        return (T)Convert.ChangeType(value, typeof(T));
+    }
+
+    public static string ItemEx(this DataRow row, string columnName, string defaultValue)
+    {
+        return row.ItemEx<string>(columnName, defaultValue);
+    }
+}

EnvelopeGenerator.ServiceHost/Extensions/DependencyInjection.cs

@@ -0,0 +1,34 @@
+using EnvelopeGenerator.ServiceHost.Jobs;
+using EnvelopeGenerator.ServiceHost.Jobs.FinalizeDocument;
+using GdPicture14;
+using Microsoft.Extensions.Options;
+
+namespace EnvelopeGenerator.ServiceHost.Extensions;
+
+public static class DependencyInjection
+{
+    [Obsolete("Check obsoleted services")]
+    public static IServiceCollection AddFinalizeDocumentJob(this IServiceCollection services, IConfiguration configuration)
+    {
+        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>();
+        services.AddScoped<PDFBurner>();
+        services.AddScoped<PDFMerger>();
+        services.AddScoped<ReportCreator>();
+
+        //TODO: Check lifetime of services. They might be singleton or scoped.
+        services.AddTransient<GdViewer>();
+        services.AddSingleton<LicenseManagerFactory>();
+        services.AddTransient<AnnotationManager>();
+
+        return services;
+    }
+}

EnvelopeGenerator.ServiceHost/Extensions/LoggerExtensions.cs

@@ -0,0 +1,11 @@
+using EnvelopeGenerator.ServiceHost.Extensions;
+
+namespace EnvelopeGenerator.ServiceHost.Extensions;
+
+public static class LoggerExtensions
+{
+    public static void LogError(this ILogger logger, Exception exception)
+    {
+        logger.LogError(exception, "{message}", exception.Message);
+    }
+}

EnvelopeGenerator.ServiceHost/Jobs/ActionService.cs

@@ -0,0 +1,37 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Application.Common.Dto;
+using EnvelopeGenerator.Application.Common.Dto.Receiver;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.ServiceHost.Jobs;
+
+/// <summary>
+/// migrate from EnvelopeGenerator.CommonServices.Services.ActionService
+/// </summary>
+[Obsolete("This is a placeholder service added by copilot. Migrate the actual logic from CommonServices.Jobs")]
+public class ActionService(IRepository<History> histRepo)
+{
+    [Obsolete("This is a placeholder service added by copilot. Migrate the actual logic from CommonServices.Jobs")]
+    public bool CreateReport(EnvelopeDto envelope, CancellationToken cancel = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    [Obsolete("This is a placeholder service added by copilot. Migrate the actual logic from CommonServices.Jobs")]
+    public bool FinalizeEnvelope(EnvelopeDto envelope, CancellationToken cancel = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    [Obsolete("This is a placeholder service added by copilot. Migrate the actual logic from CommonServices.Jobs")]
+    public bool CompleteEnvelope(EnvelopeDto envelope, CancellationToken cancel = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    [Obsolete("This is a placeholder service added by copilot. Migrate the actual logic from CommonServices.Jobs")]
+    public bool CompleteEnvelope(EnvelopeDto envelope, ReceiverDto receiver, CancellationToken cancel = default)
+    {
+        throw new NotImplementedException();
+    }
+}

EnvelopeGenerator.ServiceHost/Jobs/FinalizeDocument/PDFBurner.cs

@@ -0,0 +1,422 @@
+using System.Collections.Immutable;
+using System.Drawing;
+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;
+using Newtonsoft.Json;
+
+namespace EnvelopeGenerator.ServiceHost.Jobs.FinalizeDocument;
+
+public class PDFBurner(IOptions<WorkerOptions> workerOptions, EGDbContext context, ILogger<PDFBurner> logger, LicenseManagerFactory licenseManagerFactory, AnnotationManager manager)
+{
+    private readonly WorkerOptions.PDFBurnerOptions _options = workerOptions.Value.PdfBurner;
+    
+    public byte[] BurnAnnotsToPDF(byte[] sourceBuffer, List<string> instantJsonList, int envelopeId)
+    {
+        var envelope = context.Envelopes.FirstOrDefault(env => env.Id == envelopeId);
+        if (envelope is null)
+        {
+            throw new BurnAnnotationException($"Envelope with Id {envelopeId} not found.");
+        }
+
+        if (envelope.ReadOnly)
+        {
+            return sourceBuffer;
+        }
+
+        var elements = context.DocumentReceiverElements
+            .Where(sig => sig.Document.EnvelopeId == envelopeId)
+            .Include(sig => sig.Annotations)
+            .ToList();
+
+        return elements.Any()
+            ? BurnElementAnnotsToPDF(sourceBuffer, elements)
+            : BurnInstantJSONAnnotsToPDF(sourceBuffer, instantJsonList);
+    }
+
+    public byte[] BurnElementAnnotsToPDF(byte[] sourceBuffer, List<Signature> elements)
+    {
+        using (var doc = Pdf.FromMemory(sourceBuffer))
+        {
+            sourceBuffer = doc.Background(elements, 1.9500000000000002 * 0.93, 2.52 * 0.67).ExportStream().ToArray();
+
+            using var sourceStream = new MemoryStream(sourceBuffer);
+            var result = manager.InitFromStream(sourceStream);
+            if (result != GdPictureStatus.OK)
+            {
+                throw new BurnAnnotationException($"Could not open document for burning: [{result}]");
+            }
+
+            var margin = 0.2;
+            var inchFactor = 72d;
+
+            var keys = new[] { "position", "city", "date" };
+            var unitYOffsets = 0.2;
+            var yOffsetsOfFF = keys
+                .Select((k, i) => new { Key = k, Value = unitYOffsets * i + 1 })
+                .ToDictionary(x => x.Key, x => x.Value);
+
+            foreach (var element in elements)
+            {
+                var frameX = element.Left - 0.7 - margin;
+
+                var frame = element.Annotations.FirstOrDefault(a => a.Name == "frame");
+                var frameY = element.Top - 0.5 - margin;
+                var frameYShift = (frame?.Y ?? 0) - frameY * inchFactor;
+                var frameXShift = (frame?.X ?? 0) - frameX * inchFactor;
+
+                foreach (var annot in element.Annotations)
+                {
+                    var yOffsetOfFF = yOffsetsOfFF.TryGetValue(annot.Name, out var offset) ? offset : 0;
+                    var y = frameY + yOffsetOfFF;
+
+                    if (annot.Type == AnnotationType.FormField)
+                    {
+                        AddFormFieldValue(annot.X / inchFactor, y, annot.Width / inchFactor, annot.Height / inchFactor, element.Page, annot.Value);
+                    }
+                    else if (annot.Type == AnnotationType.Image)
+                    {
+                        AddImageAnnotation(
+                            annot.X / inchFactor,
+                            annot.Name == "signature" ? (annot.Y - frameYShift) / inchFactor : y,
+                            annot.Width / inchFactor,
+                            annot.Height / inchFactor,
+                            element.Page,
+                            annot.Value);
+                    }
+                    else if (annot.Type == AnnotationType.Ink)
+                    {
+                        AddInkAnnotation(element.Page, annot.Value);
+                    }
+                }
+            }
+
+            using var newStream = new MemoryStream();
+            result = manager.SaveDocumentToPDF(newStream);
+            if (result != GdPictureStatus.OK)
+            {
+                throw new BurnAnnotationException($"Could not save document to stream: [{result}]");
+            }
+
+            manager.Close();
+
+            return newStream.ToArray();
+        }
+    }
+
+    public byte[] BurnInstantJSONAnnotsToPDF(byte[] sourceBuffer, List<string> instantJsonList)
+    {
+        using var sourceStream = new MemoryStream(sourceBuffer);
+        var result = manager.InitFromStream(sourceStream);
+        if (result != GdPictureStatus.OK)
+        {
+            throw new BurnAnnotationException($"Could not open document for burning: [{result}]");
+        }
+
+        foreach (var json in instantJsonList)
+        {
+            try
+            {
+                AddInstantJSONAnnotationToPDF(json);
+            }
+            catch (Exception ex)
+            {
+                logger.LogWarning("Error in AddInstantJSONAnnotationToPDF - oJson: ");
+                logger.LogWarning(json);
+                throw new BurnAnnotationException("Adding Annotation failed", ex);
+            }
+        }
+
+        result = manager.BurnAnnotationsToPage(RemoveInitialAnnots: true, VectorMode: true);
+        if (result != GdPictureStatus.OK)
+        {
+            throw new BurnAnnotationException($"Could not burn annotations to file: [{result}]");
+        }
+
+        using var newStream = new MemoryStream();
+        result = manager.SaveDocumentToPDF(newStream);
+        if (result != GdPictureStatus.OK)
+        {
+            throw new BurnAnnotationException($"Could not save document to stream: [{result}]");
+        }
+
+        manager.Close();
+
+        return newStream.ToArray();
+    }
+
+    private void AddInstantJSONAnnotationToPDF(string instantJson)
+    {
+        var annotationData = JsonConvert.DeserializeObject<AnnotationData>(instantJson);
+        if (annotationData is null)
+        {
+            return;
+        }
+
+        annotationData.annotations.Reverse();
+
+        foreach (var annotation in annotationData.annotations)
+        {
+            logger.LogDebug("Adding AnnotationID: " + annotation.id);
+
+            switch (annotation.type)
+            {
+                case AnnotationType.Image:
+                    AddImageAnnotation(annotation, annotationData.attachments);
+                    break;
+                case AnnotationType.Ink:
+                    AddInkAnnotation(annotation);
+                    break;
+                case AnnotationType.Widget:
+                    var formFieldValue = annotationData.formFieldValues.FirstOrDefault(fv => fv.name == annotation.id);
+                    if (formFieldValue is not null && !_options.IgnoredLabels.Contains(formFieldValue.value))
+                    {
+                        AddFormFieldValue(annotation, formFieldValue);
+                    }
+                    break;
+            }
+        }
+    }
+
+    private void AddImageAnnotation(double x, double y, double width, double height, int page, string base64)
+    {
+        manager.SelectPage(page);
+        manager.AddEmbeddedImageAnnotFromBase64(base64, (float) x, (float) y, (float) width, (float) height);
+    }
+
+    private void AddImageAnnotation(Annotation annotation, Dictionary<string, Attachment> attachments)
+    {
+        var attachment = attachments.Where(a => a.Key == annotation.imageAttachmentId).SingleOrDefault();
+
+        var bounds = annotation.bbox.Select(ToInches).ToList();
+
+        var x = bounds[0];
+        var y = bounds[1];
+        var width = bounds[2];
+        var height = bounds[3];
+
+        manager.SelectPage(annotation.pageIndex + 1);
+        manager.AddEmbeddedImageAnnotFromBase64(attachment.Value.binary, (float) x, (float) y, (float) width, (float) height);
+    }
+
+    private void AddInkAnnotation(int page, string value)
+    {
+        var ink = JsonConvert.DeserializeObject<Ink>(value);
+        if (ink is null)
+        {
+            return;
+        }
+
+        var segments = ink.lines.points;
+        var color = ColorTranslator.FromHtml(ink.strokeColor);
+        manager.SelectPage(page);
+
+        foreach (var segment in segments)
+        {
+            var points = segment.Select(ToPointF).ToArray();
+            manager.AddFreeHandAnnot(color, points);
+        }
+    }
+
+    private void AddInkAnnotation(Annotation annotation)
+    {
+        var segments = annotation.lines.points;
+        var color = ColorTranslator.FromHtml(annotation.strokeColor);
+        manager.SelectPage(annotation.pageIndex + 1);
+
+        foreach (var segment in segments)
+        {
+            var points = segment.Select(ToPointF).ToArray();
+            manager.AddFreeHandAnnot(color, points);
+        }
+    }
+
+    private void AddFormFieldValue(double x, double y, double width, double height, int page, string value)
+    {
+        manager.SelectPage(page);
+
+        var annot = manager.AddTextAnnot((float) x, (float) y, (float) width, (float) height, value);
+        annot.FontName = _options.FontName;
+        annot.FontSize = _options.FontSize;
+        annot.FontStyle = _options.FontStyle;
+        manager.SaveAnnotationsToPage();
+    }
+
+    private void AddFormFieldValue(Annotation annotation, FormFieldValue formFieldValue)
+    {
+        var ffIndex = EGName.Index[annotation.egName];
+
+        var bounds = annotation.bbox.Select(ToInches).ToList();
+
+        var x = bounds[0];
+        var y = bounds[1] + _options.YOffset * ffIndex + _options.TopMargin;
+        var width = bounds[2];
+        var height = bounds[3];
+
+        manager.SelectPage(annotation.pageIndex + 1);
+        var annot = manager.AddTextAnnot((float) x, (float) y, (float) width, (float) height, formFieldValue.value);
+        annot.FontName = _options.FontName;
+        annot.FontSize = _options.FontSize;
+        annot.FontStyle = _options.FontStyle;
+        manager.SaveAnnotationsToPage();
+    }
+
+    private static PointF ToPointF(List<float> points)
+    {
+        var convertedPoints = points.Select(ToInches).ToList();
+        return new PointF(convertedPoints[0], convertedPoints[1]);
+    }
+
+    private static double ToInches(double value) => value / 72;
+
+    private static float ToInches(float value) => value / 72;
+
+    internal static class AnnotationType
+    {
+        public const string Image = "pspdfkit/image";
+        public const string Ink = "pspdfkit/ink";
+        public const string Widget = "pspdfkit/widget";
+        public const string FormField = "pspdfkit/form-field-value";
+    }
+
+    internal class AnnotationData
+    {
+        public List<Annotation> annotations { get; set; } = new();
+
+        public IEnumerable<List<Annotation>> AnnotationsByReceiver => annotations
+            .Where(annot => annot.hasStructuredID)
+            .GroupBy(a => a.receiverId)
+            .Select(g => g.ToList());
+
+        public IEnumerable<List<Annotation>> UnstructuredAnnotations => annotations
+            .Where(annot => !annot.hasStructuredID)
+            .GroupBy(a => a.receiverId)
+            .Select(g => g.ToList());
+
+        public Dictionary<string, Attachment> attachments { get; set; } = new();
+        public List<FormFieldValue> formFieldValues { get; set; } = new();
+    }
+
+    internal class Annotation
+    {
+        private string? _id;
+
+        public int envelopeId;
+        public int receiverId;
+        public int index;
+        public string egName = EGName.NoName;
+        public bool hasStructuredID;
+
+        public bool isLabel
+        {
+            get
+            {
+                if (string.IsNullOrEmpty(egName))
+                {
+                    return false;
+                }
+
+                var parts = egName.Split('_');
+                return parts.Length > 1 && parts[1] == "label";
+            }
+        }
+
+        public string id
+        {
+            get => _id ?? string.Empty;
+            set
+            {
+                _id = value;
+
+                if (string.IsNullOrWhiteSpace(_id))
+                {
+                    throw new BurnAnnotationException("The identifier of annotation is null or empty.");
+                }
+
+                var parts = value.Split('#');
+
+                if (parts.Length != 4)
+                {
+                    return;
+                }
+
+                if (!int.TryParse(parts[0], out envelopeId))
+                {
+                    throw new BurnAnnotationException($"The envelope ID of annotation is not integer. Id: {_id}");
+                }
+
+                if (!int.TryParse(parts[1], out receiverId))
+                {
+                    throw new BurnAnnotationException($"The receiver ID of annotation is not integer. Id: {_id}");
+                }
+
+                if (!int.TryParse(parts[2], out index))
+                {
+                    throw new BurnAnnotationException($"The index of annotation is not integer. Id: {_id}");
+                }
+
+                egName = parts[3];
+
+                hasStructuredID = true;
+            }
+        }
+
+        public List<double> bbox { get; set; } = new();
+
+        public string type { get; set; } = string.Empty;
+
+        public bool isSignature { get; set; }
+
+        public string imageAttachmentId { get; set; } = string.Empty;
+
+        public Lines lines { get; set; } = new();
+
+        public int pageIndex { get; set; }
+
+        public string strokeColor { get; set; } = string.Empty;
+    }
+
+    internal class Ink
+    {
+        public Lines lines { get; set; } = new();
+
+        public string strokeColor { get; set; } = string.Empty;
+    }
+
+    public class EGName
+    {
+        public static readonly string NoName = Guid.NewGuid().ToString();
+        public static readonly string Seal = "signature";
+
+        public static readonly ImmutableDictionary<string, int> Index = new Dictionary<string, int>
+        {
+            { NoName, 0 },
+            { Seal, 0 },
+            { "position", 1 },
+            { "city", 2 },
+            { "date", 3 }
+        }.ToImmutableDictionary();
+    }
+
+    internal class Lines
+    {
+        public List<List<List<float>>> points { get; set; } = new();
+    }
+
+    internal class Attachment
+    {
+        public string binary { get; set; } = string.Empty;
+        public string contentType { get; set; } = string.Empty;
+    }
+
+    internal class FormFieldValue
+    {
+        public string name { get; set; } = string.Empty;
+        public string value { get; set; } = string.Empty;
+    }
+}

EnvelopeGenerator.ServiceHost/Jobs/FinalizeDocument/PDFMerger.cs

@@ -0,0 +1,62 @@
+using EnvelopeGenerator.ServiceHost.Exceptions;
+using EnvelopeGenerator.ServiceHost.Jobs;
+using GdPicture14;
+using Microsoft.Extensions.Options;
+
+namespace EnvelopeGenerator.ServiceHost.Jobs.FinalizeDocument;
+
+public class PDFMerger
+{
+    private readonly AnnotationManager _manager;
+    private readonly LicenseManagerFactory _licenseManagerFactory;
+
+    private const bool AllowRasterization = true;
+    private const bool AllowVectorization = true;
+
+    private readonly PdfConversionConformance _pdfaConformanceLevel = PdfConversionConformance.PDF_A_1b;
+
+    public PDFMerger(LicenseManagerFactory licenseManagerFactory, AnnotationManager annotationManager)
+    {
+        _licenseManagerFactory = licenseManagerFactory;
+        _manager = annotationManager;
+    }
+
+    public byte[] MergeDocuments(byte[] document, byte[] report)
+    {
+        using var documentStream = new MemoryStream(document);
+        using var reportStream = new MemoryStream(report);
+        using var finalStream = new MemoryStream();
+        using var documentPdf = new GdPicturePDF();
+        using var reportPdf = new GdPicturePDF();
+
+        documentPdf.LoadFromStream(documentStream, true);
+        var status = documentPdf.GetStat();
+        if (status != GdPictureStatus.OK)
+        {
+            throw new MergeDocumentException($"Document could not be loaded: {status}");
+        }
+
+        reportPdf.LoadFromStream(reportStream, true);
+        status = reportPdf.GetStat();
+        if (status != GdPictureStatus.OK)
+        {
+            throw new MergeDocumentException($"Report could not be loaded: {status}");
+        }
+
+        var mergedPdf = documentPdf.Merge2Documents(documentPdf, reportPdf);
+        status = mergedPdf.GetStat();
+        if (status != GdPictureStatus.OK)
+        {
+            throw new MergeDocumentException($"Documents could not be merged: {status}");
+        }
+
+        mergedPdf.ConvertToPDFA(finalStream, _pdfaConformanceLevel, AllowVectorization, AllowRasterization);
+        status = documentPdf.GetStat();
+        if (status != GdPictureStatus.OK)
+        {
+            throw new MergeDocumentException($"Document could not be converted to PDF/A: {status}");
+        }
+
+        return finalStream.ToArray();
+    }
+}

EnvelopeGenerator.ServiceHost/Jobs/FinalizeDocument/ReportCreator.cs

@@ -0,0 +1,30 @@
+using DevExpress.Xpo;
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Application.Common.Dto;
+using EnvelopeGenerator.Domain.Entities;
+using EnvelopeGenerator.ServiceHost.Exceptions;
+
+namespace EnvelopeGenerator.ServiceHost.Jobs.FinalizeDocument;
+
+public class ReportCreator(IRepository<EnvelopeReport> reportRepo)
+{
+    public async Task<byte[]> CreateReportAsync(EnvelopeDto envelope, CancellationToken cancel = default)
+    {
+        var reports = await reportRepo.Where(r => r.EnvelopeId == envelope.Id).ToListAsync(cancel);
+
+        if (reports.Count == 0)
+            throw new CreateReportException("Could not prepare report data! No report data found!");
+
+        var items = reports
+            .Select(r => new ReportItem(r, envelope))
+            .OrderByDescending(r => r.ItemDate)
+            .ToList();
+
+        var source = new ReportSource { Items = items };
+        var report = new rptEnvelopeHistory { DataSource = source, DataMember = "Items" };
+        report.CreateDocument();
+        using var stream = new MemoryStream();
+        report.ExportToPdf(stream);
+        return stream.ToArray();
+    }
+}

EnvelopeGenerator.ServiceHost/Jobs/FinalizeDocument/ReportItem.cs

@@ -0,0 +1,37 @@
+using EnvelopeGenerator.Application.Common.Dto;
+using EnvelopeGenerator.Domain.Constants;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.ServiceHost.Jobs.FinalizeDocument;
+
+public class ReportItem
+{
+    public ReportItem() { }
+
+    public ReportItem(EnvelopeReport report, EnvelopeDto envelope)
+    {
+        CreatorFullName = envelope.User is not null
+            ? $"{envelope.User.Prename} {envelope.User.Name}".Trim()
+            : string.Empty;
+        CreatorEmailAddress = envelope.User?.Email ?? string.Empty;
+        EnvelopeTitle = report.HeadTitle ?? string.Empty;
+        EnvelopeUuid = report.HeadUuid ?? string.Empty;
+        EnvelopeCertificationType = envelope.CertificationType is int certType ? ((CertificationType)certType).ToString() : "null";
+        ItemStatus = (EnvelopeStatus)report.PosStatus;
+        ItemUserReference = report.PosWho ?? string.Empty;
+        ItemDate = report.PosWhen ?? DateTime.MinValue;
+    }
+
+    // Header fields (from Envelope)
+    public string CreatorFullName { get; set; } = string.Empty;
+    public string CreatorEmailAddress { get; set; } = string.Empty;
+    public string EnvelopeTitle { get; set; } = string.Empty;
+    public string EnvelopeUuid { get; set; } = string.Empty;
+    public string EnvelopeCertificationType { get; set; } = string.Empty;
+
+    // Detail fields (from EnvelopeReport)
+    public EnvelopeStatus ItemStatus { get; set; }
+    public string ItemStatusTranslated => ItemStatus.ToString();
+    public string ItemUserReference { get; set; } = string.Empty;
+    public DateTime ItemDate { get; set; }
+}

EnvelopeGenerator.ServiceHost/Jobs/FinalizeDocument/ReportSource.cs

@@ -0,0 +1,6 @@
+namespace EnvelopeGenerator.ServiceHost.Jobs.FinalizeDocument;
+
+public class ReportSource
+{
+    public List<ReportItem> Items { get; set; } = new();
+}

EnvelopeGenerator.ServiceHost/Jobs/FinalizeDocument/rptEnvelopeHistory.Designer.cs

@@ -0,0 +1,736 @@
+using System.ComponentModel;
+using System.Drawing;
+using System.Drawing.Printing;
+using DevExpress.DataAccess.ObjectBinding;
+using DevExpress.XtraPrinting;
+using DevExpress.XtraReports.UI;
+
+namespace EnvelopeGenerator.ServiceHost.Jobs.FinalizeDocument;
+
+public partial class rptEnvelopeHistory : XtraReport
+{
+    /// <summary>
+    /// Required designer variable.
+    /// </summary>
+    private IContainer components = null;
+
+    /// <summary>
+    /// Clean up any resources being used.
+    /// </summary>
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing && components != null)
+        {
+            components.Dispose();
+        }
+        base.Dispose(disposing);
+    }
+
+    #region Designer generated code
+
+    /// <summary>
+    /// Required method for Designer support - do not modify
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent()
+    {
+        this.components = new Container();
+        var resources = new ComponentResourceManager(typeof(rptEnvelopeHistory));
+        this.TopMargin = new TopMarginBand();
+        this.BottomMargin = new BottomMarginBand();
+        this.XrLabel1 = new XRLabel();
+        this.pageInfo1 = new XRPageInfo();
+        this.pageInfo2 = new XRPageInfo();
+        this.ReportHeader = new ReportHeaderBand();
+        this.label1 = new XRLabel();
+        this.XrTable3 = new XRTable();
+        this.XrTableRow8 = new XRTableRow();
+        this.XrTableCell13 = new XRTableCell();
+        this.XrTableCell15 = new XRTableCell();
+        this.XrTableRow9 = new XRTableRow();
+        this.XrTableCell14 = new XRTableCell();
+        this.XrTableCell17 = new XRTableCell();
+        this.XrTableCell16 = new XRTableCell();
+        this.XrTableCell18 = new XRTableCell();
+        this.XrTableRow10 = new XRTableRow();
+        this.XrTableCell19 = new XRTableCell();
+        this.XrTableCell20 = new XRTableCell();
+        this.XrTableCell21 = new XRTableCell();
+        this.XrTableCell22 = new XRTableCell();
+        this.XrTableRow11 = new XRTableRow();
+        this.XrTableCell23 = new XRTableCell();
+        this.XrTableCell24 = new XRTableCell();
+        this.XrTableCell25 = new XRTableCell();
+        this.XrTableCell26 = new XRTableCell();
+        this.GroupHeader1 = new GroupHeaderBand();
+        this.table1 = new XRTable();
+        this.tableRow1 = new XRTableRow();
+        this.tableCell1 = new XRTableCell();
+        this.tableCell2 = new XRTableCell();
+        this.tableCell3 = new XRTableCell();
+        this.Detail = new DetailBand();
+        this.table2 = new XRTable();
+        this.tableRow2 = new XRTableRow();
+        this.tableCell4 = new XRTableCell();
+        this.tableCell5 = new XRTableCell();
+        this.tableCell6 = new XRTableCell();
+        this.Title = new XRControlStyle();
+        this.DetailCaption1 = new XRControlStyle();
+        this.DetailData1 = new XRControlStyle();
+        this.DetailData3_Odd = new XRControlStyle();
+        this.PageInfo = new XRControlStyle();
+        this.ObjectDataSource1 = new ObjectDataSource(this.components);
+        ((ISupportInitialize)this.XrTable3).BeginInit();
+        ((ISupportInitialize)this.table1).BeginInit();
+        ((ISupportInitialize)this.table2).BeginInit();
+        ((ISupportInitialize)this.ObjectDataSource1).BeginInit();
+        ((ISupportInitialize)this).BeginInit();
+        //
+        // TopMargin
+        //
+        this.TopMargin.Dpi = 254F;
+        this.TopMargin.HeightF = 190.6042F;
+        this.TopMargin.Name = "TopMargin";
+        //
+        // BottomMargin
+        //
+        this.BottomMargin.Controls.AddRange(new XRControl[] { this.XrLabel1, this.pageInfo1, this.pageInfo2 });
+        this.BottomMargin.Dpi = 254F;
+        this.BottomMargin.Name = "BottomMargin";
+        //
+        // XrLabel1
+        //
+        this.XrLabel1.BorderColor = Color.FromArgb(165, 36, 49);
+        this.XrLabel1.Borders = BorderSide.Top;
+        this.XrLabel1.Dpi = 254F;
+        this.XrLabel1.Font = new Font("Arial", 8.25F, FontStyle.Bold);
+        this.XrLabel1.LocationFloat = new DevExpress.Utils.PointFloat(896.5417F, 0F);
+        this.XrLabel1.Name = "XrLabel1";
+        this.XrLabel1.Padding = new PaddingInfo(0, 0, 0, 0, 254F);
+        this.XrLabel1.SizeF = new SizeF(645.5836F, 58F);
+        this.XrLabel1.StyleName = "Title";
+        this.XrLabel1.StylePriority.UseBorderColor = false;
+        this.XrLabel1.StylePriority.UseBorders = false;
+        this.XrLabel1.StylePriority.UseFont = false;
+        this.XrLabel1.StylePriority.UsePadding = false;
+        this.XrLabel1.Text = "Erstellt mit SignFlow";
+        //
+        // pageInfo1
+        //
+        this.pageInfo1.BorderColor = Color.FromArgb(165, 36, 49);
+        this.pageInfo1.Borders = BorderSide.Top;
+        this.pageInfo1.Dpi = 254F;
+        this.pageInfo1.LocationFloat = new DevExpress.Utils.PointFloat(0F, 0F);
+        this.pageInfo1.Name = "pageInfo1";
+        this.pageInfo1.PageInfo = DevExpress.XtraPrinting.PageInfo.DateTime;
+        this.pageInfo1.SizeF = new SizeF(896.5417F, 58F);
+        this.pageInfo1.StyleName = "PageInfo";
+        this.pageInfo1.StylePriority.UseBorderColor = false;
+        this.pageInfo1.StylePriority.UseBorders = false;
+        this.pageInfo1.TextFormatString = "{0:dddd, d. MMMM yyyy HH:mm}";
+        //
+        // pageInfo2
+        //
+        this.pageInfo2.BorderColor = Color.FromArgb(165, 36, 49);
+        this.pageInfo2.Borders = BorderSide.Top;
+        this.pageInfo2.Dpi = 254F;
+        this.pageInfo2.LocationFloat = new DevExpress.Utils.PointFloat(1542.125F, 0F);
+        this.pageInfo2.Name = "pageInfo2";
+        this.pageInfo2.SizeF = new SizeF(357.875F, 58F);
+        this.pageInfo2.StyleName = "PageInfo";
+        this.pageInfo2.StylePriority.UseBorderColor = false;
+        this.pageInfo2.StylePriority.UseBorders = false;
+        this.pageInfo2.TextAlignment = TextAlignment.TopRight;
+        this.pageInfo2.TextFormatString = "Seite {0} von {1}";
+        //
+        // ReportHeader
+        //
+        this.ReportHeader.Controls.AddRange(new XRControl[] { this.label1, this.XrTable3 });
+        this.ReportHeader.Dpi = 254F;
+        this.ReportHeader.HeightF = 406.0843F;
+        this.ReportHeader.Name = "ReportHeader";
+        //
+        // label1
+        //
+        this.label1.BackColor = Color.FromArgb(224, 224, 224);
+        this.label1.BorderColor = Color.FromArgb(165, 36, 49);
+        this.label1.Borders = BorderSide.Bottom;
+        this.label1.BorderWidth = 2F;
+        this.label1.Dpi = 254F;
+        this.label1.Font = new Font("Segoe UI", 14.25F, FontStyle.Bold, GraphicsUnit.Point, 0);
+        this.label1.ForeColor = Color.Black;
+        this.label1.LocationFloat = new DevExpress.Utils.PointFloat(0.0002422333F, 0F);
+        this.label1.Name = "label1";
+        this.label1.Padding = new PaddingInfo(10, 10, 5, 5, 254F);
+        this.label1.SizeF = new SizeF(1900F, 77.32857F);
+        this.label1.StyleName = "Title";
+        this.label1.StylePriority.UseBackColor = false;
+        this.label1.StylePriority.UseBorderColor = false;
+        this.label1.StylePriority.UseBorders = false;
+        this.label1.StylePriority.UseBorderWidth = false;
+        this.label1.StylePriority.UseFont = false;
+        this.label1.StylePriority.UseForeColor = false;
+        this.label1.StylePriority.UsePadding = false;
+        this.label1.Text = "Signierungszertifikat";
+        //
+        // XrTable3
+        //
+        this.XrTable3.Dpi = 254F;
+        this.XrTable3.LocationFloat = new DevExpress.Utils.PointFloat(0.0002422333F, 96.60422F);
+        this.XrTable3.Name = "XrTable3";
+        this.XrTable3.OddStyleName = "DetailData3_Odd";
+        this.XrTable3.Rows.AddRange(new XRTableRow[] { this.XrTableRow8, this.XrTableRow9, this.XrTableRow10, this.XrTableRow11 });
+        this.XrTable3.SizeF = new SizeF(1900F, 284.4801F);
+        //
+        // XrTableRow8
+        //
+        this.XrTableRow8.Cells.AddRange(new XRTableCell[] { this.XrTableCell13, this.XrTableCell15 });
+        this.XrTableRow8.Dpi = 254F;
+        this.XrTableRow8.Name = "XrTableRow8";
+        this.XrTableRow8.Weight = 1D;
+        //
+        // XrTableCell13
+        //
+        this.XrTableCell13.BackColor = Color.FromArgb(224, 224, 224);
+        this.XrTableCell13.BorderColor = Color.FromArgb(165, 36, 49);
+        this.XrTableCell13.Borders = BorderSide.Bottom;
+        this.XrTableCell13.BorderWidth = 1F;
+        this.XrTableCell13.Dpi = 254F;
+        this.XrTableCell13.ForeColor = Color.Black;
+        this.XrTableCell13.Name = "XrTableCell13";
+        this.XrTableCell13.StyleName = "DetailCaption1";
+        this.XrTableCell13.StylePriority.UseBackColor = false;
+        this.XrTableCell13.StylePriority.UseBorderColor = false;
+        this.XrTableCell13.StylePriority.UseBorders = false;
+        this.XrTableCell13.StylePriority.UseBorderWidth = false;
+        this.XrTableCell13.StylePriority.UseForeColor = false;
+        this.XrTableCell13.Text = "Ersteller";
+        this.XrTableCell13.Weight = 0.38139956730411484D;
+        //
+        // XrTableCell15
+        //
+        this.XrTableCell15.BackColor = Color.FromArgb(224, 224, 224);
+        this.XrTableCell15.BorderColor = Color.FromArgb(165, 36, 49);
+        this.XrTableCell15.Borders = BorderSide.Bottom;
+        this.XrTableCell15.BorderWidth = 1F;
+        this.XrTableCell15.Dpi = 254F;
+        this.XrTableCell15.ForeColor = Color.Black;
+        this.XrTableCell15.Name = "XrTableCell15";
+        this.XrTableCell15.StyleName = "DetailCaption1";
+        this.XrTableCell15.StylePriority.UseBackColor = false;
+        this.XrTableCell15.StylePriority.UseBorderColor = false;
+        this.XrTableCell15.StylePriority.UseBorders = false;
+        this.XrTableCell15.StylePriority.UseBorderWidth = false;
+        this.XrTableCell15.StylePriority.UseForeColor = false;
+        this.XrTableCell15.Text = "Umschlag";
+        this.XrTableCell15.Weight = 0.49859081604996847D;
+        //
+        // XrTableRow9
+        //
+        this.XrTableRow9.Cells.AddRange(new XRTableCell[] { this.XrTableCell14, this.XrTableCell17, this.XrTableCell16, this.XrTableCell18 });
+        this.XrTableRow9.Dpi = 254F;
+        this.XrTableRow9.Name = "XrTableRow9";
+        this.XrTableRow9.Weight = 1D;
+        //
+        // XrTableCell14
+        //
+        this.XrTableCell14.BackColor = Color.White;
+        this.XrTableCell14.BorderColor = Color.Empty;
+        this.XrTableCell14.Borders = BorderSide.None;
+        this.XrTableCell14.Dpi = 254F;
+        this.XrTableCell14.Font = new Font("Arial", 8.25F, FontStyle.Bold, GraphicsUnit.Point, 0);
+        this.XrTableCell14.ForeColor = Color.Black;
+        this.XrTableCell14.Multiline = true;
+        this.XrTableCell14.Name = "XrTableCell14";
+        this.XrTableCell14.StyleName = "DetailCaption1";
+        this.XrTableCell14.StylePriority.UseBackColor = false;
+        this.XrTableCell14.StylePriority.UseBorderColor = false;
+        this.XrTableCell14.StylePriority.UseBorders = false;
+        this.XrTableCell14.StylePriority.UseFont = false;
+        this.XrTableCell14.StylePriority.UseForeColor = false;
+        this.XrTableCell14.Text = "Name";
+        this.XrTableCell14.Weight = 0.11578820509129036D;
+        //
+        // XrTableCell17
+        //
+        this.XrTableCell17.BackColor = Color.White;
+        this.XrTableCell17.BorderColor = Color.Empty;
+        this.XrTableCell17.Borders = BorderSide.None;
+        this.XrTableCell17.Dpi = 254F;
+        this.XrTableCell17.ExpressionBindings.AddRange(new ExpressionBinding[] { new ExpressionBinding("BeforePrint", "Text", "[CreatorFullName]") });
+        this.XrTableCell17.Font = new Font("Arial", 8.25F, FontStyle.Regular, GraphicsUnit.Point, 0);
+        this.XrTableCell17.ForeColor = Color.Black;
+        this.XrTableCell17.Multiline = true;
+        this.XrTableCell17.Name = "XrTableCell17";
+        this.XrTableCell17.StyleName = "DetailCaption1";
+        this.XrTableCell17.StylePriority.UseBackColor = false;
+        this.XrTableCell17.StylePriority.UseBorderColor = false;
+        this.XrTableCell17.StylePriority.UseBorders = false;
+        this.XrTableCell17.StylePriority.UseFont = false;
+        this.XrTableCell17.StylePriority.UseForeColor = false;
+        this.XrTableCell17.Text = "XrTableCell17";
+        this.XrTableCell17.Weight = 0.2656113622128245D;
+        //
+        // XrTableCell16
+        //
+        this.XrTableCell16.BackColor = Color.White;
+        this.XrTableCell16.BorderColor = Color.Empty;
+        this.XrTableCell16.Borders = BorderSide.None;
+        this.XrTableCell16.Dpi = 254F;
+        this.XrTableCell16.Font = new Font("Arial", 8.25F, FontStyle.Bold, GraphicsUnit.Point, 0);
+        this.XrTableCell16.ForeColor = Color.Black;
+        this.XrTableCell16.Multiline = true;
+        this.XrTableCell16.Name = "XrTableCell16";
+        this.XrTableCell16.StyleName = "DetailCaption1";
+        this.XrTableCell16.StylePriority.UseBackColor = false;
+        this.XrTableCell16.StylePriority.UseBorderColor = false;
+        this.XrTableCell16.StylePriority.UseBorders = false;
+        this.XrTableCell16.StylePriority.UseFont = false;
+        this.XrTableCell16.StylePriority.UseForeColor = false;
+        this.XrTableCell16.Text = "Titel";
+        this.XrTableCell16.Weight = 0.11578821158083684D;
+        //
+        // XrTableCell18
+        //
+        this.XrTableCell18.BackColor = Color.White;
+        this.XrTableCell18.BorderColor = Color.Empty;
+        this.XrTableCell18.Borders = BorderSide.None;
+        this.XrTableCell18.Dpi = 254F;
+        this.XrTableCell18.ExpressionBindings.AddRange(new ExpressionBinding[] { new ExpressionBinding("BeforePrint", "Text", "[EnvelopeTitle]") });
+        this.XrTableCell18.Font = new Font("Arial", 8.25F, FontStyle.Regular, GraphicsUnit.Point, 0);
+        this.XrTableCell18.ForeColor = Color.Black;
+        this.XrTableCell18.Multiline = true;
+        this.XrTableCell18.Name = "XrTableCell18";
+        this.XrTableCell18.StyleName = "DetailCaption1";
+        this.XrTableCell18.StylePriority.UseBackColor = false;
+        this.XrTableCell18.StylePriority.UseBorderColor = false;
+        this.XrTableCell18.StylePriority.UseBorders = false;
+        this.XrTableCell18.StylePriority.UseFont = false;
+        this.XrTableCell18.StylePriority.UseForeColor = false;
+        this.XrTableCell18.Text = "XrTableCell18";
+        this.XrTableCell18.Weight = 0.38280260446913167D;
+        //
+        // XrTableRow10
+        //
+        this.XrTableRow10.Cells.AddRange(new XRTableCell[] { this.XrTableCell19, this.XrTableCell20, this.XrTableCell21, this.XrTableCell22 });
+        this.XrTableRow10.Dpi = 254F;
+        this.XrTableRow10.Name = "XrTableRow10";
+        this.XrTableRow10.Weight = 1D;
+        //
+        // XrTableCell19
+        //
+        this.XrTableCell19.BackColor = Color.White;
+        this.XrTableCell19.BorderColor = Color.Empty;
+        this.XrTableCell19.Borders = BorderSide.None;
+        this.XrTableCell19.Dpi = 254F;
+        this.XrTableCell19.Font = new Font("Arial", 8.25F, FontStyle.Bold, GraphicsUnit.Point, 0);
+        this.XrTableCell19.ForeColor = Color.Black;
+        this.XrTableCell19.Multiline = true;
+        this.XrTableCell19.Name = "XrTableCell19";
+        this.XrTableCell19.StyleName = "DetailCaption1";
+        this.XrTableCell19.StylePriority.UseBackColor = false;
+        this.XrTableCell19.StylePriority.UseBorderColor = false;
+        this.XrTableCell19.StylePriority.UseBorders = false;
+        this.XrTableCell19.StylePriority.UseFont = false;
+        this.XrTableCell19.StylePriority.UseForeColor = false;
+        this.XrTableCell19.Text = "EmailAddress";
+        this.XrTableCell19.Weight = 0.11578820509129036D;
+        //
+        // XrTableCell20
+        //
+        this.XrTableCell20.BackColor = Color.White;
+        this.XrTableCell20.BorderColor = Color.Empty;
+        this.XrTableCell20.Borders = BorderSide.None;
+        this.XrTableCell20.Dpi = 254F;
+        this.XrTableCell20.ExpressionBindings.AddRange(new ExpressionBinding[] { new ExpressionBinding("BeforePrint", "Text", "[CreatorEmailAddress]") });
+        this.XrTableCell20.Font = new Font("Arial", 8.25F, FontStyle.Regular, GraphicsUnit.Point, 0);
+        this.XrTableCell20.ForeColor = Color.Black;
+        this.XrTableCell20.Multiline = true;
+        this.XrTableCell20.Name = "XrTableCell20";
+        this.XrTableCell20.StyleName = "DetailCaption1";
+        this.XrTableCell20.StylePriority.UseBackColor = false;
+        this.XrTableCell20.StylePriority.UseBorderColor = false;
+        this.XrTableCell20.StylePriority.UseBorders = false;
+        this.XrTableCell20.StylePriority.UseFont = false;
+        this.XrTableCell20.StylePriority.UseForeColor = false;
+        this.XrTableCell20.Text = "XrTableCell20";
+        this.XrTableCell20.Weight = 0.2656113622128245D;
+        //
+        // XrTableCell21
+        //
+        this.XrTableCell21.BackColor = Color.White;
+        this.XrTableCell21.BorderColor = Color.Empty;
+        this.XrTableCell21.Borders = BorderSide.None;
+        this.XrTableCell21.Dpi = 254F;
+        this.XrTableCell21.Font = new Font("Arial", 8.25F, FontStyle.Bold, GraphicsUnit.Point, 0);
+        this.XrTableCell21.ForeColor = Color.Black;
+        this.XrTableCell21.Multiline = true;
+        this.XrTableCell21.Name = "XrTableCell21";
+        this.XrTableCell21.StyleName = "DetailCaption1";
+        this.XrTableCell21.StylePriority.UseBackColor = false;
+        this.XrTableCell21.StylePriority.UseBorderColor = false;
+        this.XrTableCell21.StylePriority.UseBorders = false;
+        this.XrTableCell21.StylePriority.UseFont = false;
+        this.XrTableCell21.StylePriority.UseForeColor = false;
+        this.XrTableCell21.Text = "Umschlag-ID";
+        this.XrTableCell21.Weight = 0.11578821158083684D;
+        //
+        // XrTableCell22
+        //
+        this.XrTableCell22.BackColor = Color.White;
+        this.XrTableCell22.BorderColor = Color.Empty;
+        this.XrTableCell22.Borders = BorderSide.None;
+        this.XrTableCell22.Dpi = 254F;
+        this.XrTableCell22.ExpressionBindings.AddRange(new ExpressionBinding[] { new ExpressionBinding("BeforePrint", "Text", "[EnvelopeUuid]") });
+        this.XrTableCell22.Font = new Font("Arial", 8.25F, FontStyle.Regular, GraphicsUnit.Point, 0);
+        this.XrTableCell22.ForeColor = Color.Black;
+        this.XrTableCell22.Multiline = true;
+        this.XrTableCell22.Name = "XrTableCell22";
+        this.XrTableCell22.StyleName = "DetailCaption1";
+        this.XrTableCell22.StylePriority.UseBackColor = false;
+        this.XrTableCell22.StylePriority.UseBorderColor = false;
+        this.XrTableCell22.StylePriority.UseBorders = false;
+        this.XrTableCell22.StylePriority.UseFont = false;
+        this.XrTableCell22.StylePriority.UseForeColor = false;
+        this.XrTableCell22.Text = "XrTableCell22";
+        this.XrTableCell22.Weight = 0.38280260446913167D;
+        //
+        // XrTableRow11
+        //
+        this.XrTableRow11.Cells.AddRange(new XRTableCell[] { this.XrTableCell23, this.XrTableCell24, this.XrTableCell25, this.XrTableCell26 });
+        this.XrTableRow11.Dpi = 254F;
+        this.XrTableRow11.Name = "XrTableRow11";
+        this.XrTableRow11.Weight = 1D;
+        //
+        // XrTableCell23
+        //
+        this.XrTableCell23.BackColor = Color.White;
+        this.XrTableCell23.BorderColor = Color.Empty;
+        this.XrTableCell23.Borders = BorderSide.None;
+        this.XrTableCell23.Dpi = 254F;
+        this.XrTableCell23.Font = new Font("Arial", 8.25F, FontStyle.Bold, GraphicsUnit.Point, 0);
+        this.XrTableCell23.ForeColor = Color.Black;
+        this.XrTableCell23.Multiline = true;
+        this.XrTableCell23.Name = "XrTableCell23";
+        this.XrTableCell23.StyleName = "DetailCaption1";
+        this.XrTableCell23.StylePriority.UseBackColor = false;
+        this.XrTableCell23.StylePriority.UseBorderColor = false;
+        this.XrTableCell23.StylePriority.UseBorders = false;
+        this.XrTableCell23.StylePriority.UseFont = false;
+        this.XrTableCell23.StylePriority.UseForeColor = false;
+        this.XrTableCell23.Weight = 0.11578820509129036D;
+        //
+        // XrTableCell24
+        //
+        this.XrTableCell24.BackColor = Color.White;
+        this.XrTableCell24.BorderColor = Color.Empty;
+        this.XrTableCell24.Borders = BorderSide.None;
+        this.XrTableCell24.Dpi = 254F;
+        this.XrTableCell24.Font = new Font("Arial", 8.25F, FontStyle.Regular, GraphicsUnit.Point, 0);
+        this.XrTableCell24.ForeColor = Color.Black;
+        this.XrTableCell24.Multiline = true;
+        this.XrTableCell24.Name = "XrTableCell24";
+        this.XrTableCell24.StyleName = "DetailCaption1";
+        this.XrTableCell24.StylePriority.UseBackColor = false;
+        this.XrTableCell24.StylePriority.UseBorderColor = false;
+        this.XrTableCell24.StylePriority.UseBorders = false;
+        this.XrTableCell24.StylePriority.UseFont = false;
+        this.XrTableCell24.StylePriority.UseForeColor = false;
+        this.XrTableCell24.Weight = 0.2656113622128245D;
+        //
+        // XrTableCell25
+        //
+        this.XrTableCell25.BackColor = Color.White;
+        this.XrTableCell25.BorderColor = Color.Empty;
+        this.XrTableCell25.Borders = BorderSide.None;
+        this.XrTableCell25.Dpi = 254F;
+        this.XrTableCell25.Font = new Font("Arial", 8.25F, FontStyle.Bold, GraphicsUnit.Point, 0);
+        this.XrTableCell25.ForeColor = Color.Black;
+        this.XrTableCell25.Multiline = true;
+        this.XrTableCell25.Name = "XrTableCell25";
+        this.XrTableCell25.StyleName = "DetailCaption1";
+        this.XrTableCell25.StylePriority.UseBackColor = false;
+        this.XrTableCell25.StylePriority.UseBorderColor = false;
+        this.XrTableCell25.StylePriority.UseBorders = false;
+        this.XrTableCell25.StylePriority.UseFont = false;
+        this.XrTableCell25.StylePriority.UseForeColor = false;
+        this.XrTableCell25.Text = "Zertifizierung";
+        this.XrTableCell25.Weight = 0.11578821158083684D;
+        //
+        // XrTableCell26
+        //
+        this.XrTableCell26.BackColor = Color.White;
+        this.XrTableCell26.BorderColor = Color.Empty;
+        this.XrTableCell26.Borders = BorderSide.None;
+        this.XrTableCell26.Dpi = 254F;
+        this.XrTableCell26.ExpressionBindings.AddRange(new ExpressionBinding[] { new ExpressionBinding("BeforePrint", "Text", "[EnvelopeCertificationType]") });
+        this.XrTableCell26.Font = new Font("Arial", 8.25F, FontStyle.Regular, GraphicsUnit.Point, 0);
+        this.XrTableCell26.ForeColor = Color.Black;
+        this.XrTableCell26.Multiline = true;
+        this.XrTableCell26.Name = "XrTableCell26";
+        this.XrTableCell26.StyleName = "DetailCaption1";
+        this.XrTableCell26.StylePriority.UseBackColor = false;
+        this.XrTableCell26.StylePriority.UseBorderColor = false;
+        this.XrTableCell26.StylePriority.UseBorders = false;
+        this.XrTableCell26.StylePriority.UseFont = false;
+        this.XrTableCell26.StylePriority.UseForeColor = false;
+        this.XrTableCell26.Text = "XrTableCell26";
+        this.XrTableCell26.Weight = 0.38280260446913161D;
+        //
+        // GroupHeader1
+        //
+        this.GroupHeader1.Controls.AddRange(new XRControl[] { this.table1 });
+        this.GroupHeader1.Dpi = 254F;
+        this.GroupHeader1.GroupUnion = GroupUnion.WithFirstDetail;
+        this.GroupHeader1.HeightF = 71.12F;
+        this.GroupHeader1.Name = "GroupHeader1";
+        //
+        // table1
+        //
+        this.table1.Dpi = 254F;
+        this.table1.LocationFloat = new DevExpress.Utils.PointFloat(0F, 0F);
+        this.table1.Name = "table1";
+        this.table1.Rows.AddRange(new XRTableRow[] { this.tableRow1 });
+        this.table1.SizeF = new SizeF(1900F, 71.12F);
+        //
+        // tableRow1
+        //
+        this.tableRow1.Cells.AddRange(new XRTableCell[] { this.tableCell1, this.tableCell2, this.tableCell3 });
+        this.tableRow1.Dpi = 254F;
+        this.tableRow1.Name = "tableRow1";
+        this.tableRow1.Weight = 1D;
+        //
+        // tableCell1
+        //
+        this.tableCell1.BackColor = Color.FromArgb(224, 224, 224);
+        this.tableCell1.BorderColor = Color.FromArgb(165, 36, 49);
+        this.tableCell1.Borders = BorderSide.Bottom;
+        this.tableCell1.BorderWidth = 1F;
+        this.tableCell1.Dpi = 254F;
+        this.tableCell1.ForeColor = Color.Black;
+        this.tableCell1.Name = "tableCell1";
+        this.tableCell1.StyleName = "DetailCaption1";
+        this.tableCell1.StylePriority.UseBackColor = false;
+        this.tableCell1.StylePriority.UseBorderColor = false;
+        this.tableCell1.StylePriority.UseBorders = false;
+        this.tableCell1.StylePriority.UseBorderWidth = false;
+        this.tableCell1.StylePriority.UseForeColor = false;
+        this.tableCell1.Text = "Ereignis";
+        this.tableCell1.Weight = 0.51726482588176181D;
+        //
+        // tableCell2
+        //
+        this.tableCell2.BackColor = Color.FromArgb(224, 224, 224);
+        this.tableCell2.BorderColor = Color.FromArgb(165, 36, 49);
+        this.tableCell2.Borders = BorderSide.Bottom;
+        this.tableCell2.BorderWidth = 1F;
+        this.tableCell2.Dpi = 254F;
+        this.tableCell2.ForeColor = Color.Black;
+        this.tableCell2.Name = "tableCell2";
+        this.tableCell2.StyleName = "DetailCaption1";
+        this.tableCell2.StylePriority.UseBackColor = false;
+        this.tableCell2.StylePriority.UseBorderColor = false;
+        this.tableCell2.StylePriority.UseBorders = false;
+        this.tableCell2.StylePriority.UseBorderWidth = false;
+        this.tableCell2.StylePriority.UseForeColor = false;
+        this.tableCell2.Text = "Benutzer";
+        this.tableCell2.Weight = 0.45140669898958585D;
+        //
+        // tableCell3
+        //
+        this.tableCell3.BackColor = Color.FromArgb(224, 224, 224);
+        this.tableCell3.BorderColor = Color.FromArgb(165, 36, 49);
+        this.tableCell3.Borders = BorderSide.Bottom;
+        this.tableCell3.BorderWidth = 1F;
+        this.tableCell3.Dpi = 254F;
+        this.tableCell3.ForeColor = Color.Black;
+        this.tableCell3.Name = "tableCell3";
+        this.tableCell3.StyleName = "DetailCaption1";
+        this.tableCell3.StylePriority.UseBackColor = false;
+        this.tableCell3.StylePriority.UseBorderColor = false;
+        this.tableCell3.StylePriority.UseBorders = false;
+        this.tableCell3.StylePriority.UseBorderWidth = false;
+        this.tableCell3.StylePriority.UseForeColor = false;
+        this.tableCell3.Text = "Zeitstempel";
+        this.tableCell3.Weight = 0.22479583469004233D;
+        //
+        // Detail
+        //
+        this.Detail.Controls.AddRange(new XRControl[] { this.table2 });
+        this.Detail.Dpi = 254F;
+        this.Detail.HeightF = 86.174F;
+        this.Detail.HierarchyPrintOptions.Indent = 50.8F;
+        this.Detail.Name = "Detail";
+        //
+        // table2
+        //
+        this.table2.Dpi = 254F;
+        this.table2.LocationFloat = new DevExpress.Utils.PointFloat(0F, 0F);
+        this.table2.Name = "table2";
+        this.table2.Rows.AddRange(new XRTableRow[] { this.tableRow2 });
+        this.table2.SizeF = new SizeF(1900F, 63.42F);
+        //
+        // tableRow2
+        //
+        this.tableRow2.Cells.AddRange(new XRTableCell[] { this.tableCell4, this.tableCell5, this.tableCell6 });
+        this.tableRow2.Dpi = 254F;
+        this.tableRow2.Name = "tableRow2";
+        this.tableRow2.Weight = 11.683999633789062D;
+        //
+        // tableCell4
+        //
+        this.tableCell4.Borders = BorderSide.None;
+        this.tableCell4.Dpi = 254F;
+        this.tableCell4.ExpressionBindings.AddRange(new ExpressionBinding[] { new ExpressionBinding("BeforePrint", "Text", "[ItemStatusTranslated]") });
+        this.tableCell4.Name = "tableCell4";
+        this.tableCell4.StyleName = "DetailData1";
+        this.tableCell4.StylePriority.UseBorders = false;
+        this.tableCell4.Weight = 0.51726482142156094D;
+        //
+        // tableCell5
+        //
+        this.tableCell5.Dpi = 254F;
+        this.tableCell5.ExpressionBindings.AddRange(new ExpressionBinding[] { new ExpressionBinding("BeforePrint", "Text", "[ItemUserReference]") });
+        this.tableCell5.Name = "tableCell5";
+        this.tableCell5.StyleName = "DetailData1";
+        this.tableCell5.Weight = 0.45140669932916544D;
+        //
+        // tableCell6
+        //
+        this.tableCell6.Dpi = 254F;
+        this.tableCell6.ExpressionBindings.AddRange(new ExpressionBinding[] { new ExpressionBinding("BeforePrint", "Text", "[ItemDate]") });
+        this.tableCell6.Name = "tableCell6";
+        this.tableCell6.StyleName = "DetailData1";
+        this.tableCell6.StylePriority.UseTextAlignment = false;
+        this.tableCell6.TextAlignment = TextAlignment.MiddleRight;
+        this.tableCell6.Weight = 0.22479581593269077D;
+        //
+        // Title
+        //
+        this.Title.BackColor = Color.Transparent;
+        this.Title.BorderColor = Color.Black;
+        this.Title.Borders = BorderSide.None;
+        this.Title.BorderWidth = 1F;
+        this.Title.Font = new Font("Arial", 14.25F);
+        this.Title.ForeColor = Color.FromArgb(75, 75, 75);
+        this.Title.Name = "Title";
+        this.Title.Padding = new PaddingInfo(15, 15, 0, 0, 254F);
+        //
+        // DetailCaption1
+        //
+        this.DetailCaption1.BackColor = Color.FromArgb(75, 75, 75);
+        this.DetailCaption1.BorderColor = Color.White;
+        this.DetailCaption1.Borders = BorderSide.Left;
+        this.DetailCaption1.BorderWidth = 2F;
+        this.DetailCaption1.Font = new Font("Arial", 8.25F, FontStyle.Bold);
+        this.DetailCaption1.ForeColor = Color.White;
+        this.DetailCaption1.Name = "DetailCaption1";
+        this.DetailCaption1.Padding = new PaddingInfo(15, 15, 0, 0, 254F);
+        this.DetailCaption1.TextAlignment = TextAlignment.MiddleLeft;
+        //
+        // DetailData1
+        //
+        this.DetailData1.BorderColor = Color.Transparent;
+        this.DetailData1.Borders = BorderSide.Left;
+        this.DetailData1.BorderWidth = 2F;
+        this.DetailData1.Font = new Font("Arial", 8.25F);
+        this.DetailData1.ForeColor = Color.Black;
+        this.DetailData1.Name = "DetailData1";
+        this.DetailData1.Padding = new PaddingInfo(15, 15, 0, 0, 254F);
+        this.DetailData1.TextAlignment = TextAlignment.MiddleLeft;
+        //
+        // DetailData3_Odd
+        //
+        this.DetailData3_Odd.BackColor = Color.FromArgb(231, 231, 231);
+        this.DetailData3_Odd.BorderColor = Color.Transparent;
+        this.DetailData3_Odd.Borders = BorderSide.None;
+        this.DetailData3_Odd.BorderWidth = 1F;
+        this.DetailData3_Odd.Font = new Font("Arial", 8.25F);
+        this.DetailData3_Odd.ForeColor = Color.Black;
+        this.DetailData3_Odd.Name = "DetailData3_Odd";
+        this.DetailData3_Odd.Padding = new PaddingInfo(15, 15, 0, 0, 254F);
+        this.DetailData3_Odd.TextAlignment = TextAlignment.MiddleLeft;
+        //
+        // PageInfo
+        //
+        this.PageInfo.Font = new Font("Arial", 8.25F, FontStyle.Bold);
+        this.PageInfo.ForeColor = Color.FromArgb(75, 75, 75);
+        this.PageInfo.Name = "PageInfo";
+        this.PageInfo.Padding = new PaddingInfo(15, 15, 0, 0, 254F);
+        //
+        // ObjectDataSource1
+        //
+        this.ObjectDataSource1.DataMember = "Items";
+        this.ObjectDataSource1.Name = "ObjectDataSource1";
+        //
+        // rptEnvelopeHistory
+        //
+        this.Bands.AddRange(new Band[] { this.TopMargin, this.BottomMargin, this.ReportHeader, this.GroupHeader1, this.Detail });
+        this.ComponentStorage.AddRange(new IComponent[] { this.ObjectDataSource1 });
+        this.DataSource = this.ObjectDataSource1;
+        this.Dpi = 254F;
+        this.Font = new Font("Arial", 9.75F);
+        this.Margins = new Margins(100, 100, 191, 100);
+        this.PageHeight = 2970;
+        this.PageWidth = 2100;
+        this.PaperKind = (DevExpress.Drawing.Printing.DXPaperKind)System.Drawing.Printing.PaperKind.A4;
+        this.ReportUnit = ReportUnit.TenthsOfAMillimeter;
+        this.SnapGridSize = 25F;
+        this.StyleSheet.AddRange(new XRControlStyle[] { this.Title, this.DetailCaption1, this.DetailData1, this.DetailData3_Odd, this.PageInfo });
+        this.Version = "24.2";
+        this.Watermark.ImageSource = new DevExpress.XtraPrinting.Drawing.ImageSource("img", resources.GetString("rptEnvelopeHistory.Watermark.ImageSource"));
+        this.Watermark.ImageTransparency = 220;
+        ((ISupportInitialize)this.XrTable3).EndInit();
+        ((ISupportInitialize)this.table1).EndInit();
+        ((ISupportInitialize)this.table2).EndInit();
+        ((ISupportInitialize)this.ObjectDataSource1).EndInit();
+        ((ISupportInitialize)this).EndInit();
+    }
+
+    #endregion
+
+    private TopMarginBand TopMargin;
+    private BottomMarginBand BottomMargin;
+    private XRPageInfo pageInfo1;
+    private XRPageInfo pageInfo2;
+    private ReportHeaderBand ReportHeader;
+    private XRLabel label1;
+    private GroupHeaderBand GroupHeader1;
+    private XRTable table1;
+    private XRTableRow tableRow1;
+    private XRTableCell tableCell1;
+    private XRTableCell tableCell2;
+    private XRTableCell tableCell3;
+    private DetailBand Detail;
+    private XRTable table2;
+    private XRTableRow tableRow2;
+    private XRTableCell tableCell4;
+    private XRTableCell tableCell5;
+    private XRTableCell tableCell6;
+    private ObjectDataSource ObjectDataSource1;
+    private XRControlStyle Title;
+    private XRControlStyle DetailCaption1;
+    private XRControlStyle DetailData1;
+    private XRControlStyle DetailData3_Odd;
+    private XRControlStyle PageInfo;
+    private XRLabel XrLabel1;
+    private XRTable XrTable3;
+    private XRTableRow XrTableRow8;
+    private XRTableCell XrTableCell13;
+    private XRTableCell XrTableCell15;
+    private XRTableRow XrTableRow9;
+    private XRTableCell XrTableCell14;
+    private XRTableCell XrTableCell17;
+    private XRTableCell XrTableCell16;
+    private XRTableCell XrTableCell18;
+    private XRTableRow XrTableRow10;
+    private XRTableCell XrTableCell19;
+    private XRTableCell XrTableCell20;
+    private XRTableCell XrTableCell21;
+    private XRTableCell XrTableCell22;
+    private XRTableRow XrTableRow11;
+    private XRTableCell XrTableCell23;
+    private XRTableCell XrTableCell24;
+    private XRTableCell XrTableCell25;
+    private XRTableCell XrTableCell26;
+}

EnvelopeGenerator.ServiceHost/Jobs/FinalizeDocument/rptEnvelopeHistory.cs

@@ -0,0 +1,9 @@
+namespace EnvelopeGenerator.ServiceHost.Jobs.FinalizeDocument;
+
+public partial class rptEnvelopeHistory
+{
+    public rptEnvelopeHistory()
+    {
+        InitializeComponent();
+    }
+}

EnvelopeGenerator.ServiceHost/Jobs/FinalizeDocumentJob.cs

@@ -0,0 +1,154 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Application.Common.Dto;
+using EnvelopeGenerator.Application.Configuration.Queries;
+using EnvelopeGenerator.Application.Envelopes.Queries;
+using EnvelopeGenerator.Domain.Constants;
+using EnvelopeGenerator.Domain.Entities;
+using EnvelopeGenerator.ServiceHost.Exceptions;
+using EnvelopeGenerator.ServiceHost.Extensions;
+using EnvelopeGenerator.ServiceHost.Jobs.FinalizeDocument;
+using GdPicture14;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Options;
+using System.Data;
+
+namespace EnvelopeGenerator.ServiceHost.Jobs;
+
+[Obsolete("ActionService is a placeholder service added by copilot. Migrate the actual logic from CommonServices.Jobs")]
+public class FinalizeDocumentJob(IOptions<WorkerOptions> options, ILogger<FinalizeDocumentJob> logger, TempFiles tempFiles, ActionService actionService, PDFBurner pdfBurner, PDFMerger pdfMerger, ReportCreator reportCreator, GdViewer? _gdViewer, LicenseManager licenseManager, IMediator mediator, IRepository<Envelope> envRepo, IRepository<Domain.Entities.DocumentStatus> docStatusRepo)
+{
+    private readonly WorkerOptions _options = options.Value;
+
+    private ConfigDto? _config;
+    
+    private const int CompleteWaitTime = 1;
+    private string _parentFolderUid = string.Empty;
+
+    private sealed class EnvelopeData
+    {
+        public int EnvelopeId { get; set; }
+        public string EnvelopeUuid { get; set; } = string.Empty;
+        public string DocumentPath { get; set; } = string.Empty;
+        public List<string> AnnotationData { get; set; } = new();
+        public byte[]? DocAsByte { get; set; }
+    }
+
+    public bool RethrowOnError { get; set; } = true;
+
+    public async Task ExecuteAsync(IEnumerable<EnvelopeDto> envelopes, CancellationToken cancel = default)
+    {
+        tempFiles.Create();
+        var jobId = typeof(FinalizeDocumentJob).FullName;
+
+        _config = await mediator.Send(new ReadDefaultConfigQuery(), cancel);
+
+        foreach (var envelope in envelopes)
+        {
+            try
+            {
+                await Finalize(envelope, cancel);
+            }
+            catch (Exception ex)
+            {
+                logger.LogWarning(ex, "An unexpected exception was ignored while processing the envelope with ID [{id}].", envelope.Id);
+
+                if(RethrowOnError)
+                    throw;
+            }
+        }
+    }
+
+    public Task ExecuteAsync(EnvelopeDto envelope, CancellationToken cancel = default) => ExecuteAsync([envelope], cancel);
+
+    public async Task ExecuteAsync(CancellationToken cancel = default)
+    {
+        var envelopes = await mediator.Send(new ReadEnvelopeQuery()
+        {
+            Status = new () { Include = [EnvelopeStatus.EnvelopeCompletelySigned] },
+            MinMinutesSinceLastChange = CompleteWaitTime,
+        }, cancel);
+
+        await ExecuteAsync(envelopes, cancel);
+    }
+
+    private async Task Finalize(EnvelopeDto envelope, CancellationToken cancel)
+    {
+        var annotations = await docStatusRepo.Where(s => s.EnvelopeId == envelope.Id).Select(s => s.Value).ToListAsync(cancel);
+        var burnedDocument = pdfBurner!.BurnAnnotsToPDF(envelope.Documents?.FirstOrDefault()?.ByteData!, annotations, envelope.Id)
+            ?? throw new ApplicationException("Document could not be finalized");
+
+        actionService.CreateReport(envelope, cancel);
+
+        var report = await reportCreator!.CreateReportAsync(envelope, cancel);
+
+        var mergedDocument = pdfMerger!.MergeDocuments(burnedDocument, report);
+
+        var outputDirectoryPath = Path.Combine(_config!.ExportPath, _parentFolderUid);
+
+        if (!Directory.Exists(outputDirectoryPath))
+            Directory.CreateDirectory(outputDirectoryPath);
+
+        var outputFilePath = Path.Combine(outputDirectoryPath, $"{envelope.Uuid}.pdf");
+
+        try
+        {
+            File.WriteAllBytes(outputFilePath, mergedDocument);
+        }
+        catch (Exception ex)
+        {
+            throw new ExportDocumentException("Could not export final document to disk. Envelope Id is " + envelope.Id, ex);
+        }
+
+        var outputFile = await File.ReadAllBytesAsync(outputFilePath, cancel);
+        await envRepo.UpdateAsync(e => e.DocResult = outputFile, e => e.Id == envelope.Id, cancel);
+
+        SendFinalEmails(envelope);
+
+        actionService.FinalizeEnvelope(envelope, cancel);
+    }
+
+    private bool SendFinalEmails(EnvelopeDto envelope)
+    {
+        var mailToCreator = (FinalEmailType)(envelope.FinalEmailToCreator ?? 0);
+        var mailToReceivers = (FinalEmailType)(envelope.FinalEmailToReceivers ?? 0);
+
+        if (mailToCreator != FinalEmailType.No)
+            SendFinalEmailToCreator(envelope, mailToCreator);
+        else
+            logger?.LogWarning("No SendFinalEmailToCreator - oMailToCreator [{mailToCreator}] <> [{noFinalEmailType}] ", mailToCreator, FinalEmailType.No);
+
+        if (mailToReceivers != FinalEmailType.No)
+        {
+            SendFinalEmailToReceivers(envelope, mailToReceivers);
+        }
+        else
+        {
+            logger?.LogWarning("No SendFinalEmailToReceivers - oMailToCreator [{mailToReceivers}] <> [{noFinalEmailType}] ", mailToReceivers, FinalEmailType.No);
+        }
+
+        return true;
+    }
+
+    private bool SendFinalEmailToCreator(EnvelopeDto envelope, FinalEmailType mailToCreator)
+    {
+        if (actionService.CompleteEnvelope(envelope) == false)
+        {
+            logger?.LogError(new Exception("CompleteEnvelope failed"), "Envelope could not be completed for receiver [{email}]", envelope.User?.Email);
+            return false;
+        }
+
+        return true;
+    }
+
+    private bool SendFinalEmailToReceivers(EnvelopeDto envelope, FinalEmailType mailToReceivers)
+    {
+        foreach (var receiver in envelope.EnvelopeReceivers ?? [])
+        {
+            if (!actionService.CompleteEnvelope(envelope, receiver.Receiver!))
+                return false;
+        }
+
+        return true;
+    }
+}

EnvelopeGenerator.ServiceHost/Jobs/Infrastructure/Database.cs

@@ -0,0 +1,60 @@
+using System.Data;
+using Microsoft.Data.SqlClient;
+
+namespace EnvelopeGenerator.ServiceHost.Jobs.Infrastructure;
+
+public class MSSQLServer(IConfiguration configuration)
+{
+    private readonly string _connectionString = configuration.GetConnectionString("Default") 
+        ?? throw new InvalidOperationException("Connection string 'Default' not found.");
+
+    public static string DecryptConnectionString(string connectionString) => connectionString;
+
+    public SqlConnection GetConnection
+    {
+        get
+        {
+            var connection = new SqlConnection(_connectionString);
+            if (connection.State != ConnectionState.Open)
+            {
+                connection.Open();
+            }
+
+            return connection;
+        }
+    }
+
+    public DataTable GetDatatable(string sql)
+    {
+        using var connection = new SqlConnection(_connectionString);
+        using var command = new SqlCommand(sql, connection);
+        using var adapter = new SqlDataAdapter(command);
+        var table = new DataTable();
+        adapter.Fill(table);
+        return table;
+    }
+
+    public object? GetScalarValue(string sql)
+    {
+        using var connection = new SqlConnection(_connectionString);
+        using var command = new SqlCommand(sql, connection);
+        connection.Open();
+        return command.ExecuteScalar();
+    }
+
+    public bool ExecuteNonQuery(string sql)
+    {
+        using var connection = new SqlConnection(_connectionString);
+        using var command = new SqlCommand(sql, connection);
+        connection.Open();
+        return command.ExecuteNonQuery() > 0;
+    }
+
+    public bool ExecuteNonQuery(SqlCommand command)
+    {
+        using var connection = new SqlConnection(_connectionString);
+        command.Connection = connection;
+        connection.Open();
+        return command.ExecuteNonQuery() > 0;
+    }
+}

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/TempFiles.cs

@@ -0,0 +1,84 @@
+using EnvelopeGenerator.ServiceHost.Extensions;
+
+namespace EnvelopeGenerator.ServiceHost.Jobs;
+
+[Obsolete("Use memory cache instead of temp files.")]
+public class TempFiles
+{
+
+    [Obsolete("Use memory cache instead of temp files.")]
+    public string TempPath { get; }
+
+    private readonly ILogger<TempFiles> _logger;
+
+
+    [Obsolete("Use memory cache instead of temp files.")]
+    public TempFiles(ILogger<TempFiles> logger)
+    {
+        _logger = logger;
+        var tempDirectoryPath = Path.GetTempPath();
+        TempPath = Path.Combine(tempDirectoryPath, "EnvelopeGenerator");
+    }
+
+
+    [Obsolete("Use memory cache instead of temp files.")]
+    public bool Create()
+    {
+        try
+        {
+            if (!Directory.Exists(TempPath))
+            {
+                Directory.CreateDirectory(TempPath);
+            }
+            else
+            {
+                CleanUpFiles();
+            }
+
+            return true;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex);
+            return false;
+        }
+    }
+
+
+    [Obsolete("Use memory cache instead of temp files.")]
+    private bool CleanUpFiles()
+    {
+        try
+        {
+            foreach (var fileItem in Directory.GetFiles(TempPath))
+            {
+                _logger.LogDebug("Deleting tempPath-file: {fileItem} ...", fileItem);
+                File.Delete(fileItem);
+            }
+
+            return true;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex);
+            return false;
+        }
+    }
+
+
+    [Obsolete("Use memory cache instead of temp files.")]
+    public bool CleanUp()
+    {
+        try
+        {
+            _logger.LogDebug("Deleting tempPath-Data: {TempPath} ...", TempPath);
+            Directory.Delete(TempPath, true);
+            return true;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex);
+            return false;
+        }
+    }
+}

EnvelopeGenerator.ServiceHost/Jobs/WorkerOptions.cs

@@ -0,0 +1,37 @@
+namespace EnvelopeGenerator.ServiceHost.Jobs;
+
+public class WorkerOptions
+{
+    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();
+
+    public record PDFBurnerOptions
+    {
+        public List<string> IgnoredLabels { get; set; } = ["Date", "Datum", "ZIP", "PLZ", "Place", "Ort", "Position", "Stellung"];
+
+        public double TopMargin { get; set; } = 0.1;
+
+        public double YOffset { get; set; } = -0.3;
+
+        public string FontName { get; set; } = "Arial";
+
+        public int FontSize { get; set; } = 8;
+
+        public FontStyle FontStyle { get; set; } = FontStyle.Italic;
+    }
+}

EnvelopeGenerator.ServiceHost/Middleware/ExceptionHandlingMiddleware.cs

@@ -0,0 +1,75 @@
+namespace EnvelopeGenerator.ServiceHost.Middleware;
+
+using DigitalData.Core.Exceptions;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging;
+using System.Net;
+using System.Text.Json;
+
+/// <summary>
+/// Middleware for handling exceptions globally in the application.
+/// Captures exceptions thrown during the request pipeline execution,
+/// logs them, and returns an appropriate HTTP response with a JSON error message.
+/// </summary>
+/// <remarks>
+/// Initializes a new instance of the <see cref="ExceptionHandlingMiddleware"/> class.
+/// </remarks>
+/// <param name="next">The next middleware in the request pipeline.</param>
+/// <param name="logger">The logger instance for logging exceptions.</param>
+public class ExceptionHandlingMiddleware(RequestDelegate next, ILogger<ExceptionHandlingMiddleware> logger)
+{
+    /// <summary>
+    /// Invokes the middleware to handle the HTTP request.
+    /// </summary>
+    /// <param name="context">The HTTP context of the current request.</param>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    public async Task InvokeAsync(HttpContext context)
+    {
+        try
+        {
+            await next(context); // Continue down the pipeline
+        }
+        catch (Exception ex)
+        {
+            await HandleExceptionAsync(context, ex, logger);
+        }
+    }
+
+    /// <summary>
+    /// Handles exceptions by logging them and writing an appropriate JSON response.
+    /// </summary>
+    /// <param name="context">The HTTP context of the current request.</param>
+    /// <param name="exception">The exception that occurred.</param>
+    /// <param name="logger">The logger instance for logging the exception.</param>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    private static async Task HandleExceptionAsync(HttpContext context, Exception exception, ILogger logger)
+    {
+        context.Response.ContentType = "application/json";
+
+        string message;
+
+        switch (exception)
+        {
+            case BadRequestException badRequestEx:
+                context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
+                message = badRequestEx.Message;
+                break;
+
+            case NotFoundException notFoundEx:
+                context.Response.StatusCode = (int)HttpStatusCode.NotFound;
+                message = notFoundEx.Message;
+                break;
+
+            default:
+                logger.LogError(exception, "Unhandled exception occurred.");
+                context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
+                message = "An unexpected error occurred.";
+                break;
+        }
+
+        await context.Response.WriteAsync(JsonSerializer.Serialize(new
+        {
+            message
+        }));
+    }
+}

EnvelopeGenerator.ServiceHost/Program.cs

@@ -0,0 +1,96 @@
+using DigitalData.UserManager.DependencyInjection;
+using EnvelopeGenerator.Application;
+using EnvelopeGenerator.Infrastructure;
+using EnvelopeGenerator.ServiceHost;
+using EnvelopeGenerator.ServiceHost.Extensions;
+using EnvelopeGenerator.ServiceHost.Middleware;
+using Microsoft.AspNetCore.Localization;
+using Microsoft.EntityFrameworkCore;
+using System.Globalization;
+
+var builder = WebApplication.CreateBuilder(args);
+
+#region Kestrel & Windows Service Configuration
+if (builder.Configuration.GetValue<bool>("UseWindowsService"))
+{
+    builder.Host.UseWindowsService();
+}
+
+if (builder.Configuration.GetValue<bool>("UseCustomKestrelEndpoints"))
+{
+    builder.WebHost.ConfigureKestrel((context, serverOptions) =>
+    {
+        var serverConfigSection = context.Configuration.GetSection("ServerConfig");
+        serverOptions.Configure(serverConfigSection);
+    });
+}
+#endregion
+
+var config = builder.Configuration;
+var connStr = config.GetConnectionString("Default") ??
+    throw new InvalidOperationException("Connection string 'Default' is missing in the configuration.");
+
+#region Service configuration
+builder.Services.AddControllers();
+builder.Services.AddHostedService<Worker>();
+builder.Services.AddDistributedSqlServerCache(options =>
+{
+    options.ConnectionString = connStr;
+    options.SchemaName = "dbo";
+    options.TableName = "TBDD_CACHE";
+});
+#pragma warning disable CS0618 
+builder.Services.AddFinalizeDocumentJob(config);
+builder.Services.AddEnvelopeGeneratorInfrastructureServices(
+    opt =>
+    {
+        opt.AddDbTriggerParams(config);
+        opt.AddDbContext((provider, options) =>
+        {
+            var logger = provider.GetRequiredService<ILogger<EGDbContext>>();
+            options.UseSqlServer(connStr)
+                    .LogTo(log => logger.LogInformation("{log}", log), Microsoft.Extensions.Logging.LogLevel.Trace)
+                    .EnableSensitiveDataLogging()
+                    .EnableDetailedErrors();
+        });
+    });
+builder.Services.AddEnvelopeGeneratorServices(config);
+builder.Services.AddMemoryCache();
+builder.Services.AddUserManager<EGDbContext>();
+#pragma warning restore CS0618
+builder.Services.AddLocalization();
+#endregion
+
+builder.Services.AddEndpointsApiExplorer();
+builder.Services.AddSwaggerGen();
+
+var app = builder.Build();
+
+app.UseMiddleware<ExceptionHandlingMiddleware>();
+
+// Configure the HTTP request pipeline.
+if (app.Environment.IsDevelopment())
+{
+    app.UseSwagger();
+    app.UseSwaggerUI();
+}
+
+#region Localizer
+var supportedCultureNames = config.GetSection("SupportedCultures").Get<string[]>() ?? ["de-DE", "en-US"];
+var supportedCultures = supportedCultureNames.Select(cName => new CultureInfo(cName)).ToList();
+var requestLocalizationOptions = new RequestLocalizationOptions
+{
+    SupportedCultures = supportedCultures,
+    SupportedUICultures = supportedCultures
+};
+requestLocalizationOptions.RequestCultureProviders.Add(new QueryStringRequestCultureProvider());
+app.UseRequestLocalization(requestLocalizationOptions);
+#endregion
+
+app.UseHttpsRedirection();
+
+app.UseAuthorization();
+
+app.MapControllers();
+
+app.Run();

EnvelopeGenerator.ServiceHost/Properties/launchSettings.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "http://json.schemastore.org/launchsettings.json",
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:27420",
+      "sslPort": 44372
+    }
+  },
+  "profiles": {
+    "http": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "applicationUrl": "http://localhost:5088",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "https": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "applicationUrl": "https://localhost:7234;http://localhost:5088",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

EnvelopeGenerator.ServiceHost/Worker.cs

@@ -0,0 +1,40 @@
+using EnvelopeGenerator.ServiceHost.Jobs;
+using Microsoft.Extensions.Options;
+
+namespace EnvelopeGenerator.ServiceHost;
+
+public class Worker : BackgroundService
+{
+    private readonly ILogger<Worker> _logger;
+    private readonly WorkerOptions _options;
+    private readonly JobStateManager _jobStateManager;
+    private readonly IServiceScopeFactory _scopeFactory;
+
+    public Worker(ILogger<Worker> logger, IOptions<WorkerOptions> options, JobStateManager jobStateManager, IServiceScopeFactory scopeFactory)
+    {
+        _logger = logger;
+        _options = options.Value;
+        _jobStateManager = jobStateManager;
+        _scopeFactory = scopeFactory;
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        while (!stoppingToken.IsCancellationRequested)
+        {
+            if (_logger.IsEnabled(LogLevel.Information))
+            {
+                _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
+            }
+
+            if (_jobStateManager.GetState<FinalizeDocumentJob>() == State.Running)
+            {
+                using var scope = _scopeFactory.CreateScope();
+                var finalizeDocumentJob = scope.ServiceProvider.GetRequiredService<FinalizeDocumentJob>();
+                await finalizeDocumentJob.ExecuteAsync(stoppingToken);
+            }
+
+            await Task.Delay(_options.DelayMilliseconds, stoppingToken);
+        }
+    }
+}

EnvelopeGenerator.ServiceHost/appsettings.Development.json

@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Information"
+    }
+  }
+}

EnvelopeGenerator.ServiceHost/appsettings.json

@@ -0,0 +1,29 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "Worker": {
+    "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" ],
+  "ConnectionStrings": {
+    "Default": "Server=SDD-VMP04-SQL17\\DD_DEVELOP01;Database=DD_ECM;User Id=sa;Password=dd;Encrypt=false;TrustServerCertificate=True;"
+  },
+  "UseWindowsService": false,
+  "UseCustomKestrelEndpoints": false,
+  "ServerConfig": {
+    "Endpoints": {
+      "Http": {
+        "Url": "http://localhost:1111"
+      }
+    }
+  }
+}

EnvelopeGenerator.Tests/Application/Fake.cs

@@ -193,13 +193,17 @@ public static class Extensions
     #endregion
 
     #region Envelope
-    public static CreateEnvelopeCommand CreateEnvelopeCommand(this Faker fake, int userId) => new()
+    public static CreateEnvelopeCommand CreateEnvelopeCommand(this Faker fake, int userId)
     {
-        Message = fake.Lorem.Paragraph(fake.Random.Number(2, 5)),
+        var cmd = new CreateEnvelopeCommand
-        Title = fake.Lorem.Words(fake.Random.Number(3, 4)).Join(" "),
+        {
-        UserId = userId,
+            Message = fake.Lorem.Paragraph(fake.Random.Number(2, 5)),
-        UseSQLExecutor = false
+            Title = fake.Lorem.Words(fake.Random.Number(3, 4)).Join(" "),
-    };
+            UseSQLExecutor = false
+        };
+        cmd.Authorize(userId);
+        return cmd;
+    }
 
     public static List<CreateEnvelopeCommand> CreateEnvelopeCommands(this Faker fake, params int[] userIDs)
         => Enumerable.Range(0, userIDs.Length)

EnvelopeGenerator.Tests/Application/MediatorExtensionsTests.cs

@@ -0,0 +1,308 @@
+using DigitalData.Core.Exceptions;
+using EnvelopeGenerator.Application.Common.Extensions;
+using MediatR;
+
+namespace EnvelopeGenerator.Tests.Application;
+
+[TestFixture]
+public class MediatorExtensionsTests
+{
+    #region Stub infrastructure
+
+    private sealed class StubRequest<TResponse> : IRequest<TResponse?> { }
+
+    /// <summary>
+    /// Minimal <see cref="ISender"/> stub that returns a pre-configured response for any <see cref="ISender.Send{TResponse}"/> call.
+    /// </summary>
+    private sealed class StubSender : ISender
+    {
+        private readonly object? _response;
+
+        public StubSender(object? response) => _response = response;
+
+        public Task<TResponse> Send<TResponse>(IRequest<TResponse> request, CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            return Task.FromResult((TResponse)_response!);
+        }
+
+        public Task Send<TRequest>(TRequest request, CancellationToken cancellationToken = default) where TRequest : IRequest
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            return Task.CompletedTask;
+        }
+
+        public Task<object?> Send(object request, CancellationToken cancellationToken = default)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            return Task.FromResult(_response);
+        }
+
+        public IAsyncEnumerable<TResponse> CreateStream<TResponse>(IStreamRequest<TResponse> request, CancellationToken cancellationToken = default)
+            => throw new NotImplementedException();
+
+        public IAsyncEnumerable<object?> CreateStream(object request, CancellationToken cancellationToken = default)
+            => throw new NotImplementedException();
+    }
+
+    private static ISender CreateSender<T>(T? response) => new StubSender(response);
+
+    #endregion
+
+    #region Throw — non-null scalar
+
+    [Test]
+    public async Task Throw_WithNonNullResponse_ReturnsResponse()
+    {
+        var sender = CreateSender<string>("hello");
+        var request = new StubRequest<string?>();
+
+        var result = await sender.GetOr(request).Throw(() => new InvalidOperationException());
+
+        Assert.That(result, Is.EqualTo("hello"));
+    }
+
+    #endregion
+
+    #region Throw — null response
+
+    [Test]
+    public void Throw_WithNullResponse_ThrowsCustomException()
+    {
+        var sender = CreateSender<string>(null);
+        var request = new StubRequest<string?>();
+
+        var ex = Assert.ThrowsAsync<InvalidOperationException>(
+            () => sender.GetOr(request).Throw(() => new InvalidOperationException("custom")));
+
+        Assert.That(ex!.Message, Is.EqualTo("custom"));
+    }
+
+    #endregion
+
+    #region Throw — empty collection
+
+    [Test]
+    public void Throw_WithEmptyList_ThrowsCustomException()
+    {
+        var sender = CreateSender<List<string>>(new List<string>());
+        var request = new StubRequest<List<string>?>();
+
+        Assert.ThrowsAsync<ArgumentException>(
+            () => sender.GetOr(request).Throw(() => new ArgumentException("empty")));
+    }
+
+    #endregion
+
+    #region Throw — non-empty collection
+
+    [Test]
+    public async Task Throw_WithNonEmptyList_ReturnsResponse()
+    {
+        var expected = new List<int> { 1, 2 };
+        var sender = CreateSender<List<int>>(expected);
+        var request = new StubRequest<List<int>?>();
+
+        var result = await sender.GetOr(request).Throw(() => new InvalidOperationException());
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    #endregion
+
+    #region Throw — string edge case (string implements IEnumerable)
+
+    [Test]
+    public async Task Throw_WithEmptyString_ReturnsEmptyString()
+    {
+        var sender = CreateSender<string>("");
+        var request = new StubRequest<string?>();
+
+        var result = await sender.GetOr(request).Throw(() => new InvalidOperationException("should not throw"));
+
+        Assert.That(result, Is.EqualTo(""));
+    }
+
+    #endregion
+
+    #region ThrowNotFound — non-null scalar
+
+    [Test]
+    public async Task ThrowNotFound_WithNonNullResponse_ReturnsResponse()
+    {
+        var sender = CreateSender<string>("hello");
+        var request = new StubRequest<string?>();
+
+        var result = await sender.GetOr(request).ThrowNotFound();
+
+        Assert.That(result, Is.EqualTo("hello"));
+    }
+
+    [Test]
+    public async Task ThrowNotFound_WithExceptionMessage_AndNonNullResponse_ReturnsResponse()
+    {
+        var sender = CreateSender<int>(42);
+        var request = new StubRequest<int?>();
+
+        var result = await sender.GetOr(request).ThrowNotFound("not found");
+
+        Assert.That(result, Is.EqualTo(42));
+    }
+
+    #endregion
+
+    #region ThrowNotFound — null response
+
+    [Test]
+    public void ThrowNotFound_WithNullResponse_ThrowsNotFoundException()
+    {
+        var sender = CreateSender<string>(null);
+        var request = new StubRequest<string?>();
+
+        Assert.ThrowsAsync<NotFoundException>(() => sender.GetOr(request).ThrowNotFound());
+    }
+
+    [Test]
+    public void ThrowNotFound_WithNullResponse_AndCustomMessage_ContainsMessage()
+    {
+        const string message = "Entity not found";
+        var sender = CreateSender<string>(null);
+        var request = new StubRequest<string?>();
+
+        var ex = Assert.ThrowsAsync<NotFoundException>(
+            () => sender.GetOr(request).ThrowNotFound(message));
+
+        Assert.That(ex!.Message, Does.Contain(message));
+    }
+
+    [Test]
+    public void ThrowNotFound_WithNullResponse_HasDefaultMessageWithTypeName()
+    {
+        var sender = CreateSender<string>(null);
+        var request = new StubRequest<string?>();
+
+        var ex = Assert.ThrowsAsync<NotFoundException>(() => sender.GetOr(request).ThrowNotFound());
+
+        Assert.That(ex!.Message, Does.Contain(nameof(String)));
+    }
+
+    #endregion
+
+    #region ThrowNotFound — empty collection
+
+    [Test]
+    public void ThrowNotFound_WithEmptyList_ThrowsNotFoundException()
+    {
+        var sender = CreateSender<List<string>>(new List<string>());
+        var request = new StubRequest<List<string>?>();
+
+        Assert.ThrowsAsync<NotFoundException>(() => sender.GetOr(request).ThrowNotFound());
+    }
+
+    [Test]
+    public void ThrowNotFound_WithEmptyArray_ThrowsNotFoundException()
+    {
+        var sender = CreateSender<int[]>(Array.Empty<int>());
+        var request = new StubRequest<int[]?>();
+
+        Assert.ThrowsAsync<NotFoundException>(() => sender.GetOr(request).ThrowNotFound());
+    }
+
+    [Test]
+    public void ThrowNotFound_WithEmptyCollection_AndCustomMessage_ContainsMessage()
+    {
+        const string message = "No items found";
+        var sender = CreateSender<List<int>>(new List<int>());
+        var request = new StubRequest<List<int>?>();
+
+        var ex = Assert.ThrowsAsync<NotFoundException>(
+            () => sender.GetOr(request).ThrowNotFound(message));
+
+        Assert.That(ex!.Message, Does.Contain(message));
+    }
+
+    #endregion
+
+    #region ThrowNotFound — non-empty collection
+
+    [Test]
+    public async Task ThrowNotFound_WithNonEmptyList_ReturnsResponse()
+    {
+        var expected = new List<string> { "a", "b" };
+        var sender = CreateSender<List<string>>(expected);
+        var request = new StubRequest<List<string>?>();
+
+        var result = await sender.GetOr(request).ThrowNotFound();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public async Task ThrowNotFound_WithNonEmptyArray_ReturnsResponse()
+    {
+        var expected = new[] { 1, 2, 3 };
+        var sender = CreateSender<int[]>(expected);
+        var request = new StubRequest<int[]?>();
+
+        var result = await sender.GetOr(request).ThrowNotFound();
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    #endregion
+
+    #region ThrowInvalidOperation — null response
+
+    [Test]
+    public void ThrowInvalidOperation_WithNullResponse_ThrowsInvalidOperationException()
+    {
+        var sender = CreateSender<string>(null);
+        var request = new StubRequest<string?>();
+
+        Assert.ThrowsAsync<InvalidOperationException>(
+            () => sender.GetOr(request).ThrowInvalidOperation());
+    }
+
+    [Test]
+    public void ThrowInvalidOperation_WithNullResponse_AndCustomMessage_ContainsMessage()
+    {
+        const string message = "Something went wrong";
+        var sender = CreateSender<string>(null);
+        var request = new StubRequest<string?>();
+
+        var ex = Assert.ThrowsAsync<InvalidOperationException>(
+            () => sender.GetOr(request).ThrowInvalidOperation(message));
+
+        Assert.That(ex!.Message, Does.Contain(message));
+    }
+
+    #endregion
+
+    #region CancellationToken
+
+    [Test]
+    public void Throw_WithCancelledToken_ThrowsOperationCanceledException()
+    {
+        var sender = CreateSender<string>("value");
+        var request = new StubRequest<string?>();
+        var cts = new CancellationTokenSource();
+        cts.Cancel();
+
+        Assert.ThrowsAsync<OperationCanceledException>(
+            () => sender.GetOr(request, cts.Token).Throw(() => new InvalidOperationException()));
+    }
+
+    [Test]
+    public void ThrowNotFound_WithCancelledToken_ThrowsOperationCanceledException()
+    {
+        var sender = CreateSender<string>("value");
+        var request = new StubRequest<string?>();
+        var cts = new CancellationTokenSource();
+        cts.Cancel();
+
+        Assert.ThrowsAsync<OperationCanceledException>(
+            () => sender.GetOr(request, cts.Token).ThrowNotFound());
+    }
+
+    #endregion
+}

EnvelopeGenerator.Tests/Domain/ConstantsTests.cs

@@ -1,17 +0,0 @@
-using EnvelopeGenerator.Domain.Constants;
-using NUnit.Framework;
-
-namespace EnvelopeGenerator.Tests.Domain;
-
-public class ConstantsTests
-{
-    [TestCase(EnvelopeSigningType.ReadAndSign, EnvelopeSigningType.ReadAndSign)]
-    [TestCase(EnvelopeSigningType.WetSignature, EnvelopeSigningType.WetSignature)]
-    [TestCase((EnvelopeSigningType)5, EnvelopeSigningType.WetSignature)]
-    public void Normalize_ReturnsExpectedValue(EnvelopeSigningType input, EnvelopeSigningType expected)
-    {
-        var normalized = input.Normalize();
-
-        Assert.That(normalized, Is.EqualTo(expected));
-    }
-}

EnvelopeGenerator.Tests/EnvelopeGenerator.Tests.csproj

@@ -53,4 +53,8 @@
     </None>
   </ItemGroup>
 
+  <ItemGroup>
+    <Folder Include="Domain\" />
+  </ItemGroup>
+
 </Project>

EnvelopeGenerator.sln

@@ -35,6 +35,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EnvelopeGenerator.Tests", "
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EnvelopeGenerator.API", "EnvelopeGenerator.API\EnvelopeGenerator.API.csproj", "{EC768913-6270-14F4-1DD3-69C87A659462}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EnvelopeGenerator.ServiceHost", "EnvelopeGenerator.ServiceHost\EnvelopeGenerator.ServiceHost.csproj", "{5DD82482-E560-405F-BF55-04D647B05BEF}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -85,6 +87,10 @@ Global
 		{EC768913-6270-14F4-1DD3-69C87A659462}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{EC768913-6270-14F4-1DD3-69C87A659462}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{EC768913-6270-14F4-1DD3-69C87A659462}.Release|Any CPU.Build.0 = Release|Any CPU
+		{5DD82482-E560-405F-BF55-04D647B05BEF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5DD82482-E560-405F-BF55-04D647B05BEF}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5DD82482-E560-405F-BF55-04D647B05BEF}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5DD82482-E560-405F-BF55-04D647B05BEF}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -104,6 +110,7 @@ Global
 		{211619F5-AE25-4BA5-A552-BACAFE0632D3} = {9943209E-1744-4944-B1BA-4F87FC1A0EEB}
 		{224C4845-1CDE-22B7-F3A9-1FF9297F70E8} = {0CBC2432-A561-4440-89BC-671B66A24146}
 		{EC768913-6270-14F4-1DD3-69C87A659462} = {E3C758DC-914D-4B7E-8457-0813F1FDB0CB}
+		{5DD82482-E560-405F-BF55-04D647B05BEF} = {E3C758DC-914D-4B7E-8457-0813F1FDB0CB}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {73E60370-756D-45AD-A19A-C40A02DACCC7}