Add query/handler for retrieving a single envelope

Introduced ReadSingleEnvelopeQuery and its handler to enable
retrieval of a single envelope with optional user filtering.
Supports filtering by user ID, envelope ID, or UUID, includes
related documents, and maps results to EnvelopeDto using
AutoMapper for secure and flexible access.

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;
@@ -174,4 +175,9 @@ public record EnvelopeDto : IEnvelope
     /// 
     /// </summary>
     public IEnumerable<DocumentDto>? Documents { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public IEnumerable<EnvelopeReceiverDto>? EnvelopeReceivers { get; set; }
 }

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'">
-	  <PackageReference Include="AutoMapper" Version="13.0.1" />
-	  <PackageReference Include="Microsoft.Data.SqlClient" Version="5.2.2" />
-	  <PackageReference Include="CommandDotNet">
+  <ItemGroup Condition="'$(TargetFramework)' == 'net7.0'">
+	<PackageReference Include="AutoMapper" Version="13.0.1" />
+	<PackageReference Include="Microsoft.Data.SqlClient" Version="5.2.2" />
+	<PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="7.0.20" />
+	<PackageReference Include="CommandDotNet">
 		<Version>7.0.5</Version>
-	  </PackageReference>
-	</ItemGroup>
+	</PackageReference>
+  </ItemGroup>
 
-	<ItemGroup Condition="'$(TargetFramework)' == 'net8.0'">
-	  <PackageReference Include="AutoMapper" Version="14.0.0" />
-	  <PackageReference Include="CommandDotNet">
-	    <Version>8.1.1</Version>
-	  </PackageReference>
-	</ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'net8.0'">
+	<PackageReference Include="AutoMapper" Version="14.0.0" />
+	<PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="8.0.17" />
+	<PackageReference Include="CommandDotNet">
+	  <Version>8.1.1</Version>
+	</PackageReference>
+  </ItemGroup>
 
-	<ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
-	  <PackageReference Include="AutoMapper" Version="14.0.0" />
-	  <PackageReference Include="CommandDotNet">
-	    <Version>8.1.1</Version>
-	  </PackageReference>
-	</ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
+	<PackageReference Include="AutoMapper" Version="14.0.0" />
+	<PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="9.0.6" />
+	<PackageReference Include="CommandDotNet">
+	  <Version>8.1.1</Version>
+	</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/ReadSingleEnvelopeQuery.cs

@@ -0,0 +1,71 @@
+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;
+
+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 envelope = await query
+            .Include(e => e.Documents)
+            .FirstOrDefaultAsync(cancel);
+
+        return envelope is null ? null : _mapper.Map<EnvelopeDto>(envelope);
+    }
+}

EnvelopeGenerator.ServiceHost/Controllers/WorkerController.cs

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

EnvelopeGenerator.ServiceHost/EnvelopeGenerator.ServiceHost.csproj

@@ -27,7 +27,15 @@
   </ItemGroup>
 
   <ItemGroup>
-    <Folder Include="Controllers\" />
+    <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/Extensions/DependencyInjection.cs

@@ -1,6 +1,6 @@
-using DigitalData.Modules.Database;
 using EnvelopeGenerator.ServiceHost.Jobs;
 using EnvelopeGenerator.ServiceHost.Jobs.FinalizeDocument;
+using EnvelopeGenerator.ServiceHost.Jobs.Infrastructure;
 using GdPicture14;
 using Microsoft.Extensions.Options;
 
@@ -17,8 +17,6 @@ public static class DependencyInjection
         services.AddSingleton<TempFiles>();
         services.AddScoped<PDFBurner>();
         services.AddScoped<PDFMerger>();
-        services.AddScoped<ReportModel>();
-        services.AddScoped<MSSQLServer>();
 
         //TODO: Check lifetime of services. They might be singleton or scoped.
         services.AddTransient<GdViewer>();

EnvelopeGenerator.ServiceHost/Jobs/ActionService.cs

@@ -1,4 +1,6 @@
 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;
@@ -10,25 +12,25 @@ namespace EnvelopeGenerator.ServiceHost.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(Envelope envelope, CancellationToken cancel = default)
+    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(Envelope envelope, CancellationToken cancel = default)
+    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(Envelope envelope, CancellationToken cancel = default)
+    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(Envelope envelope, Receiver receiver, CancellationToken cancel = default)
+    public bool CompleteEnvelope(EnvelopeDto envelope, ReceiverDto receiver, CancellationToken cancel = default)
     {
         throw new NotImplementedException();
     }

EnvelopeGenerator.ServiceHost/Jobs/FinalizeDocument/ReportCreator.cs

@@ -1,103 +1,30 @@
-using System.Data;
+using DevExpress.Xpo;
 using DigitalData.Core.Abstraction.Application.Repository;
-using EnvelopeGenerator.Domain.Constants;
+using EnvelopeGenerator.Application.Common.Dto;
 using EnvelopeGenerator.Domain.Entities;
 using EnvelopeGenerator.ServiceHost.Exceptions;
-using EnvelopeGenerator.ServiceHost.Extensions;
 
 namespace EnvelopeGenerator.ServiceHost.Jobs.FinalizeDocument;
 
-[Obsolete("Instead of ReportModel create and use EnvelopeReport mediator queries")]
-public class ReportCreator(ReportModel ReportModel, ILogger<ReportCreator> Logger, IRepository<EnvelopeReport> reportRepo)
+public class ReportCreator(IRepository<EnvelopeReport> reportRepo)
 {
-    [Obsolete("Solve the spaghetti...")]
-    private Envelope? _envelope;
-
-    [Obsolete("Instead of ReportModel create and use EnvelopeReport mediator queries and solve this spaghetti...")]
-    public byte[] CreateReport(Envelope envelope)
+    public async Task<byte[]> CreateReportAsync(EnvelopeDto envelope, CancellationToken cancel = default)
     {
-        try
-        {
-            Logger.LogDebug("Loading report data..");
-            var table = ReportModel.List(envelope.Id);
-            var items = GetReportSource(table);
+        var reports = await reportRepo.Where(r => r.EnvelopeId == envelope.Id).ToListAsync(cancel);
 
-            _envelope = envelope;
+        if (reports.Count == 0)
+            throw new CreateReportException("Could not prepare report data! No report data found!");
 
-            if (items.Count == 0)
-            {
-                throw new CreateReportException("No report data found!");
-            }
-
-            Logger.LogDebug("Creating report with [{count}] items..", items.Count);
-            var buffer = DoCreateReport(items);
-            Logger.LogDebug("Report created!");
-
-            return buffer;
-        }
-        catch (Exception ex)
-        {
-            Logger.LogError(ex);
-            throw new CreateReportException("Could not prepare report data!", ex);
-        }
-    }
-
-    private List<ReportItem> GetReportSource(DataTable dataTable)
-    {
-        Logger.LogDebug("Preparing report data");
-        return dataTable.Rows
-            .Cast<DataRow>()
-            .Select(ToReportItem)
+        var items = reports
+            .Select(r => new ReportItem(r, envelope))
             .OrderByDescending(r => r.ItemDate)
             .ToList();
-    }
 
-    private byte[] DoCreateReport(List<ReportItem> reportItems)
-    {
-        var items = reportItems.Select(MergeEnvelope).ToList();
         var source = new ReportSource { Items = items };
         var report = new rptEnvelopeHistory { DataSource = source, DataMember = "Items" };
-
-        Logger.LogDebug("Creating report in memory..");
         report.CreateDocument();
-
-        Logger.LogDebug("Exporting report to stream..");
         using var stream = new MemoryStream();
         report.ExportToPdf(stream);
-
-        Logger.LogDebug("Writing report to buffer..");
         return stream.ToArray();
     }
-
-    [Obsolete("Solve this spaghetti...")]
-    private ReportItem MergeEnvelope(ReportItem item)
-    {
-        if (item.Envelope is null)
-        {
-            item.Envelope = _envelope;
-        }
-
-        return item;
-    }
-
-    private ReportItem ToReportItem(DataRow row)
-    {
-        try
-        {
-            return new ReportItem
-            {
-                EnvelopeId = row.ItemEx("ENVELOPE_ID", 0),
-                EnvelopeTitle = row.ItemEx("HEAD_TITLE", string.Empty),
-                EnvelopeSubject = row.ItemEx("HEAD_SUBJECT", string.Empty),
-                ItemDate = row.ItemEx("POS_WHEN", DateTime.MinValue),
-                ItemStatus = (EnvelopeStatus)row.ItemEx("POS_STATUS", 0),
-                ItemUserReference = row.ItemEx("POS_WHO", string.Empty)
-            };
-        }
-        catch (Exception ex)
-        {
-            Logger.LogError(ex);
-            throw new CreateReportException("Could not read data from database!", ex);
-        }
-    }
 }

EnvelopeGenerator.ServiceHost/Jobs/FinalizeDocument/ReportItem.cs

@@ -1,3 +1,4 @@
+using EnvelopeGenerator.Application.Common.Dto;
 using EnvelopeGenerator.Domain.Constants;
 using EnvelopeGenerator.Domain.Entities;
 
@@ -5,15 +6,32 @@ namespace EnvelopeGenerator.ServiceHost.Jobs.FinalizeDocument;
 
 public class ReportItem
 {
-    public Envelope? Envelope { get; set; }
-    public int EnvelopeId { get; set; }
+    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 EnvelopeSubject { 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/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

@@ -1,103 +1,9 @@
-using DevExpress.XtraReports.UI;
-using DevExpress.Drawing;
-using System.Drawing;
-using System.IO;
+namespace EnvelopeGenerator.ServiceHost.Jobs.FinalizeDocument;
 
-namespace EnvelopeGenerator.ServiceHost.Jobs.FinalizeDocument;
-
-public class rptEnvelopeHistory : XtraReport
+public partial class rptEnvelopeHistory
 {
     public rptEnvelopeHistory()
     {
-        BuildLayout();
-    }
-
-    private void BuildLayout()
-    {
-        Bands.AddRange(
-        [
-            new TopMarginBand(),
-            new BottomMarginBand(),
-            new ReportHeaderBand { HeightF = 40 },
-            new PageHeaderBand { HeightF = 24 },
-            new DetailBand { HeightF = 22 }
-        ]);
-
-        var reportHeader = (ReportHeaderBand)Bands[nameof(ReportHeaderBand)]!;
-        var pageHeader = (PageHeaderBand)Bands[nameof(PageHeaderBand)]!;
-        var detail = (DetailBand)Bands[nameof(DetailBand)]!;
-
-        var title = new XRLabel
-        {
-            BoundsF = new RectangleF(0, 0, 750, 28),
-            Font = new DXFont("Segoe UI", 14, DXFontStyle.Bold),
-            Text = "Envelope History"
-        };
-        reportHeader.Controls.Add(title);
-
-        var headerTable = CreateTable(isHeader: true);
-        pageHeader.Controls.Add(headerTable);
-
-        var detailTable = CreateTable(isHeader: false);
-        detail.Controls.Add(detailTable);
-
-        Margins = new DXMargins(40, 40, 40, 40);
-        PaperKind = (DevExpress.Drawing.Printing.DXPaperKind)System.Drawing.Printing.PaperKind.A4;
-    }
-
-    private static XRTable CreateTable(bool isHeader)
-    {
-        var table = new XRTable
-        {
-            BoundsF = new RectangleF(0, 0, 750, 22),
-            Borders = DevExpress.XtraPrinting.BorderSide.All
-        };
-
-        var row = new XRTableRow();
-
-        if (isHeader)
-        {
-            row.Font = new DXFont("Segoe UI", 9, DXFontStyle.Bold);
-            row.BackColor = Color.Gainsboro;
-            row.Cells.Add(CreateCell("Date"));
-            row.Cells.Add(CreateCell("Status"));
-            row.Cells.Add(CreateCell("User"));
-            row.Cells.Add(CreateCell("Title"));
-            row.Cells.Add(CreateCell("Subject"));
-        }
-        else
-        {
-            row.Font = new DXFont("Segoe UI", 9, DXFontStyle.Regular);
-            row.Cells.Add(CreateCell("[ItemDate]"));
-            row.Cells.Add(CreateCell("[ItemStatusTranslated]"));
-            row.Cells.Add(CreateCell("[ItemUserReference]"));
-            row.Cells.Add(CreateCell("[EnvelopeTitle]"));
-            row.Cells.Add(CreateCell("[EnvelopeSubject]"));
-        }
-
-        table.Rows.Add(row);
-        return table;
-    }
-
-    private static XRTableCell CreateCell(string textOrExpression)
-    {
-        return new XRTableCell
-        {
-            Text = textOrExpression,
-            Padding = new DevExpress.XtraPrinting.PaddingInfo(4, 4, 2, 2),
-            CanGrow = false
-        };
-    }
-
-    public object? DataSource { get; set; }
-    public string? DataMember { get; set; }
-
-    public void CreateDocument()
-    {
-    }
-
-    public void ExportToPdf(Stream stream)
-    {
-        stream.Write(Array.Empty<byte>(), 0, 0);
+        InitializeComponent();
     }
 }

EnvelopeGenerator.ServiceHost/Jobs/FinalizeDocumentJob.cs

@@ -1,5 +1,4 @@
 using DigitalData.Core.Abstraction.Application.Repository;
-using DigitalData.Modules.Database;
 using EnvelopeGenerator.Application.Common.Dto;
 using EnvelopeGenerator.Application.Configuration.Queries;
 using EnvelopeGenerator.Application.Envelopes.Queries;
@@ -8,10 +7,8 @@ using EnvelopeGenerator.Domain.Entities;
 using EnvelopeGenerator.ServiceHost.Exceptions;
 using EnvelopeGenerator.ServiceHost.Extensions;
 using EnvelopeGenerator.ServiceHost.Jobs.FinalizeDocument;
-using GdPicture.Internal.MSOfficeBinary.translator.Spreadsheet.XlsFileFormat.Records;
 using GdPicture14;
 using MediatR;
-using Microsoft.Data.SqlClient;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Options;
 using System.Data;
@@ -39,7 +36,7 @@ public class FinalizeDocumentJob(IOptions<WorkerOptions> options, ILogger<Finali
 
     public bool RethrowOnError { get; set; } = true;
 
-    public async Task ExecuteAsync(CancellationToken cancel = default)
+    public async Task ExecuteAsync(IEnumerable<EnvelopeDto> envelopes, CancellationToken cancel = default)
     {
         var gdPictureKey = _options.GdPictureLicenseKey;
         tempFiles.Create();
@@ -47,16 +44,6 @@ public class FinalizeDocumentJob(IOptions<WorkerOptions> options, ILogger<Finali
 
         _config = await mediator.Send(new ReadDefaultConfigQuery(), cancel);
 
-        var envelopes = await envRepo
-            .Where(e => e.Status == EnvelopeStatus.EnvelopeCompletelySigned
-                && e.ChangedWhen.HasValue
-                && EF.Functions.DateDiffMinute(e.ChangedWhen.Value, DateTime.Now) >= CompleteWaitTime)
-            .OrderBy(e => e.Id)
-            .ToListAsync(cancel);
-
-        if (envelopes.Count > 0)
-            logger.LogInformation("Found [{count}] completed envelopes.", envelopes.Count);
-
         foreach (var envelope in envelopes)
         {
             try
@@ -65,25 +52,34 @@ public class FinalizeDocumentJob(IOptions<WorkerOptions> options, ILogger<Finali
             }
             catch (Exception ex)
             {
-                logger.LogError(ex, "Unhandled exception while working envelope [{id}]", envelope.Id);
+                logger.LogWarning(ex, "An unexpected exception was ignored while processing the envelope with ID [{id}].", envelope.Id);
 
                 if(RethrowOnError)
                     throw;
             }
-
-            logger.LogInformation("Envelope [{id}] finalized!", envelope.Id);
         }
     }
 
-    private async Task Finalize(Envelope envelope, CancellationToken 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.DefaultDocument.ByteData!, annotations, envelope.Id)
+        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 = reportCreator!.CreateReport(envelope);
+        var report = await reportCreator!.CreateReportAsync(envelope, cancel);
 
         var mergedDocument = pdfMerger!.MergeDocuments(burnedDocument, report);
 
@@ -108,10 +104,10 @@ public class FinalizeDocumentJob(IOptions<WorkerOptions> options, ILogger<Finali
 
         SendFinalEmails(envelope);
 
-        actionService?.FinalizeEnvelope(envelope, cancel);
+        actionService.FinalizeEnvelope(envelope, cancel);
     }
 
-    private bool SendFinalEmails(Envelope envelope)
+    private bool SendFinalEmails(EnvelopeDto envelope)
     {
         var mailToCreator = (FinalEmailType)(envelope.FinalEmailToCreator ?? 0);
         var mailToReceivers = (FinalEmailType)(envelope.FinalEmailToReceivers ?? 0);
@@ -133,9 +129,9 @@ public class FinalizeDocumentJob(IOptions<WorkerOptions> options, ILogger<Finali
         return true;
     }
 
-    private bool SendFinalEmailToCreator(Envelope envelope, FinalEmailType mailToCreator)
+    private bool SendFinalEmailToCreator(EnvelopeDto envelope, FinalEmailType mailToCreator)
     {
-        if (actionService?.CompleteEnvelope(envelope) == false)
+        if (actionService.CompleteEnvelope(envelope) == false)
         {
             logger?.LogError(new Exception("CompleteEnvelope failed"), "Envelope could not be completed for receiver [{email}]", envelope.User?.Email);
             return false;
@@ -144,15 +140,12 @@ public class FinalizeDocumentJob(IOptions<WorkerOptions> options, ILogger<Finali
         return true;
     }
 
-    private bool SendFinalEmailToReceivers(Envelope envelope, FinalEmailType mailToReceivers)
+    private bool SendFinalEmailToReceivers(EnvelopeDto envelope, FinalEmailType mailToReceivers)
     {
-        foreach (var receiver in envelope.EnvelopeReceivers ?? Enumerable.Empty<EnvelopeReceiver>())
+        foreach (var receiver in envelope.EnvelopeReceivers ?? [])
         {
-            if (actionService?.CompleteEnvelope(envelope, receiver.Receiver) == false)
-            {
-                logger?.LogError(new Exception("CompleteEnvelope failed"), "Envelope could not be completed for receiver [{email}]", receiver.Receiver?.EmailAddress);
+            if (!actionService.CompleteEnvelope(envelope, receiver.Receiver!))
                 return false;
-            }
         }
 
         return true;

EnvelopeGenerator.ServiceHost/Jobs/Infrastructure/Database.cs

@@ -1,7 +1,7 @@
 using System.Data;
 using Microsoft.Data.SqlClient;
 
-namespace DigitalData.Modules.Database;
+namespace EnvelopeGenerator.ServiceHost.Jobs.Infrastructure;
 
 public class MSSQLServer(IConfiguration configuration)
 {

EnvelopeGenerator.ServiceHost/Jobs/ReportModel.cs

@@ -1,15 +0,0 @@
-using DigitalData.Modules.Database;
-using System.Data;
-
-namespace EnvelopeGenerator.ServiceHost.Jobs;
-
-[Obsolete("Create and use EnvelopeReport mediator queries")]
-public class ReportModel(MSSQLServer Database)
-{
-    [Obsolete("Create and use EnvelopeReport mediator queries")]
-    public DataTable List(int envelopeId)
-    {
-        var sql = $"SELECT * FROM VWSIG_ENVELOPE_REPORT WHERE ENVELOPE_ID = {envelopeId}";
-        return Database.GetDatatable(sql);
-    }
-}

EnvelopeGenerator.ServiceHost/Jobs/WorkerOptions.cs

@@ -7,9 +7,6 @@ public class WorkerOptions
 {
     public string GdPictureLicenseKey { get; set; } = null!;
 
-    [Obsolete("Use ILogger.")]
-    public bool Debug { get; set; }
-
     public PDFBurnerOptions PdfBurner { get; set; } = new();
 
     public record PDFBurnerOptions