Add LangCode property to EmailTemplate entity

Introduced a required LangCode property to the EmailTemplate entity, mapped to the LANG_CODE column in the database as varchar(5). This supports language-specific email templates.

EnvelopeGenerator.API/Controllers/AnnotationController.cs

@@ -0,0 +1,118 @@
+using DigitalData.Core.Abstraction.Application.DTO;
+using DigitalData.Core.Exceptions;
+using EnvelopeGenerator.Application.Common.Extensions;
+using EnvelopeGenerator.Application.Common.Interfaces.Services;
+using EnvelopeGenerator.Application.Common.Notifications.DocSigned;
+using EnvelopeGenerator.Application.EnvelopeReceivers.Queries;
+using EnvelopeGenerator.Application.Histories.Queries;
+using EnvelopeGenerator.Domain.Constants;
+using EnvelopeGenerator.API.Extensions;
+using MediatR;
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Authentication.Cookies;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.API.Controllers;
+
+/// <summary>
+/// Manages annotations and signature lifecycle for envelopes.
+/// </summary>
+[Authorize(Policy = AuthPolicy.Receiver)]
+[ApiController]
+[Route("api/[controller]")]
+public class AnnotationController : ControllerBase
+{
+    [Obsolete("Use MediatR")]
+    private readonly IEnvelopeHistoryService _historyService;
+
+    [Obsolete("Use MediatR")]
+    private readonly IEnvelopeReceiverService _envelopeReceiverService;
+
+    private readonly IMediator _mediator;
+
+    private readonly ILogger<AnnotationController> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="AnnotationController"/>.
+    /// </summary>
+    [Obsolete("Use MediatR")]
+    public AnnotationController(
+        ILogger<AnnotationController> logger,
+        IEnvelopeHistoryService envelopeHistoryService,
+        IEnvelopeReceiverService envelopeReceiverService,
+        IMediator mediator)
+    {
+        _historyService = envelopeHistoryService;
+        _envelopeReceiverService = envelopeReceiverService;
+        _mediator = mediator;
+        _logger = logger;
+    }
+
+    /// <summary>
+    /// Creates or updates annotations for the authenticated envelope receiver.
+    /// </summary>
+    /// <param name="psPdfKitAnnotation">Annotation payload.</param>
+    /// <param name="cancel">Cancellation token.</param>
+    [Authorize(Policy = AuthPolicy.Receiver)]
+    [HttpPost]
+    [Obsolete("PSPDF Kit will no longer be used.")]
+    public async Task<IActionResult> CreateOrUpdate([FromBody] PsPdfKitAnnotation? psPdfKitAnnotation = null, CancellationToken cancel = default)
+    {
+        var signature = User.GetReceiverSignatureOfReceiver();
+        var uuid = User.GetEnvelopeUuidOfReceiver();
+
+        var envelopeReceiver = await _mediator.ReadEnvelopeReceiverAsync(uuid, signature, cancel).ThrowIfNull(Exceptions.NotFound);
+
+        if (!envelopeReceiver.Envelope!.ReadOnly && psPdfKitAnnotation is null)
+            return BadRequest();
+
+        if (await _mediator.IsSignedAsync(uuid, signature, cancel))
+            return Problem(statusCode: StatusCodes.Status409Conflict);
+        else if (await _mediator.AnyHistoryAsync(uuid, new[] { EnvelopeStatus.EnvelopeRejected, EnvelopeStatus.DocumentRejected }, cancel))
+            return Problem(statusCode: StatusCodes.Status423Locked);
+
+        var docSignedNotification = await _mediator
+            .ReadEnvelopeReceiverAsync(uuid, signature, cancel)
+            .ToDocSignedNotification(psPdfKitAnnotation)
+            ?? throw new NotFoundException("Envelope receiver is not found.");
+
+        await _mediator.PublishSafely(docSignedNotification, cancel);
+        await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
+
+        return Ok();
+    }
+
+    /// <summary>
+    /// Rejects the document for the current receiver.
+    /// </summary>
+    /// <param name="reason">Optional rejection reason.</param>
+    [Authorize(Policy = AuthPolicy.Receiver)]
+    [HttpPost("reject")]
+    [Obsolete("Use MediatR")]
+    public async Task<IActionResult> Reject([FromBody] string? reason = null)
+    {
+        var signature = User.GetReceiverSignatureOfReceiver();
+        var uuid = User.GetEnvelopeUuidOfReceiver();
+        var mail = User.GetReceiverMailOfReceiver();
+
+        var envRcvRes = await _envelopeReceiverService.ReadByUuidSignatureAsync(uuid: uuid, signature: signature);
+
+        if (envRcvRes.IsFailed)
+        {
+            _logger.LogNotice(envRcvRes.Notices);
+            return Unauthorized("you are not authorized");
+        }
+
+        var histRes = await _historyService.RecordAsync(envRcvRes.Data.EnvelopeId, userReference: mail, EnvelopeStatus.DocumentRejected, comment: reason);
+        if (histRes.IsSuccess)
+        {
+            await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
+            return NoContent();
+        }
+
+        _logger.LogEnvelopeError(uuid: uuid, signature: signature, message: "Unexpected error happened in api/envelope/reject");
+        _logger.LogNotice(histRes.Notices);
+        return StatusCode(500, histRes.Messages);
+    }
+}

EnvelopeGenerator.API/Controllers/AuthController.cs

@@ -0,0 +1,76 @@
+using EnvelopeGenerator.API.Controllers.Interfaces;
+using EnvelopeGenerator.API.Models;
+using EnvelopeGenerator.Domain.Constants;
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Authentication.Cookies;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
+
+namespace EnvelopeGenerator.API.Controllers;
+
+/// <summary>
+/// Controller verantwortlich für die Benutzer-Authentifizierung, einschließlich Anmelden, Abmelden und Überprüfung des Authentifizierungsstatus.
+/// </summary>
+[Route("api/[controller]")]
+[ApiController]
+public partial class AuthController(IOptions<AuthTokenKeys> authTokenKeyOptions, IAuthorizationService authService) : ControllerBase, IAuthController
+{
+    private readonly AuthTokenKeys authTokenKeys = authTokenKeyOptions.Value;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public IAuthorizationService AuthService { get; } = authService;
+
+    /// <summary>
+    /// Entfernt das Authentifizierungs-Cookie des Benutzers (AuthCookie)
+    /// </summary>
+    /// <returns>
+    /// Gibt eine HTTP 200 oder 401.
+    /// </returns>
+    /// <remarks>
+    /// Sample request:
+    ///
+    ///     POST /api/auth/logout
+    ///
+    /// </remarks>
+    /// <response code="200">Erfolgreich gelöscht, wenn der Benutzer ein berechtigtes Cookie hat.</response>
+    /// <response code="401">Wenn es kein zugelassenes Cookie gibt, wird „nicht zugelassen“ zurückgegeben.</response>
+    [ProducesResponseType(typeof(void), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
+    [Authorize(Policy = AuthPolicy.SenderOrReceiver)]
+    [HttpPost("logout")]
+    public async Task<IActionResult> Logout()
+    {
+        if (await this.IsUserInPolicyAsync(AuthPolicy.Sender))
+            Response.Cookies.Delete(authTokenKeys.Cookie);
+        else if (await this.IsUserInPolicyAsync(AuthPolicy.ReceiverOrReceiverTFA))
+            await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
+        else
+            return Unauthorized();
+
+        return Ok();
+    }
+
+    /// <summary>
+    /// Prüft, ob der Benutzer ein autorisiertes Token hat.
+    /// </summary>
+    /// <returns>Wenn ein autorisiertes Token vorhanden ist HTTP 200 asynchron 401</returns>
+    /// <remarks>
+    /// Sample request:
+    ///
+    ///     GET /api/auth
+    ///
+    /// </remarks>
+    /// <response code="200">Wenn es einen autorisierten Cookie gibt.</response>
+    /// <response code="401">Wenn kein Cookie vorhanden ist oder nicht autorisierte.</response>
+    [ProducesResponseType(typeof(void), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
+    [HttpGet("check")]
+    [Authorize]
+    public IActionResult Check(string? role = null)
+        => role is not null && !User.IsInRole(role)
+            ? Unauthorized()
+            : Ok();
+}

EnvelopeGenerator.API/Controllers/ConfigController.cs

@@ -0,0 +1,30 @@
+using EnvelopeGenerator.API.Models.PsPdfKitAnnotation;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
+
+namespace EnvelopeGenerator.API.Controllers;
+
+/// <summary>
+/// Exposes configuration data required by the client applications.
+/// </summary>
+/// <remarks>
+/// Initializes a new instance of <see cref="ConfigController"/>.
+/// </remarks>
+[Route("api/[controller]")]
+[ApiController]
+[Authorize]
+public class ConfigController(IOptionsMonitor<AnnotationParams> annotationParamsOptions) : ControllerBase
+{
+    private readonly AnnotationParams _annotationParams = annotationParamsOptions.CurrentValue;
+
+    /// <summary>
+    /// Returns annotation configuration that was previously rendered by MVC.
+    /// </summary>
+    [HttpGet("Annotations")]
+    [Obsolete("PSPDF Kit will no longer be used.")]
+    public IActionResult GetAnnotationParams()
+    {
+        return Ok(_annotationParams.AnnotationJSObject);
+    }
+}

EnvelopeGenerator.API/Controllers/DocumentController.cs

@@ -0,0 +1,63 @@
+using EnvelopeGenerator.API.Controllers.Interfaces;
+using EnvelopeGenerator.API.Extensions;
+using EnvelopeGenerator.Application.Documents.Queries;
+using EnvelopeGenerator.Domain.Constants;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.API.Controllers;
+
+/// <summary>
+/// Provides access to envelope documents for authenticated receivers.
+/// </summary>
+/// <remarks>
+/// Initializes a new instance of the <see cref="DocumentController"/> class.
+/// </remarks>
+[Authorize]
+[ApiController]
+[Route("api/[controller]")]
+public class DocumentController(IMediator mediator, IAuthorizationService authService) : ControllerBase, IAuthController
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public IAuthorizationService AuthService => authService;
+
+    /// <summary>
+    /// Returns the document bytes receiver.
+    /// </summary>
+    /// <param name="query">Encoded envelope key.</param>
+    /// <param name="cancel">Cancellation token.</param>
+    [HttpGet]
+    [Authorize(Policy = AuthPolicy.SenderOrReceiver)]
+    public async Task<IActionResult> GetDocument(CancellationToken cancel, [FromQuery] ReadDocumentQuery? query = null)
+    {
+        // Sender: expects query with envelope key
+        if (await this.IsUserInPolicyAsync(AuthPolicy.Sender))
+        {
+            if (query is null)
+                return BadRequest("Missing document query.");
+
+            var senderDoc = await mediator.Send(query, cancel);
+            return senderDoc.ByteData is byte[] senderDocByte
+                ? File(senderDocByte, "application/octet-stream")
+                : NotFound("Document is empty.");
+        }
+
+        // Receiver: resolve envelope id from claims
+        if (await this.IsUserInPolicyAsync(AuthPolicy.Receiver))
+        {           
+            if (query is not null)
+                return BadRequest("Query parameters are not allowed for receiver role.");
+
+            var envelopeId = User.GetEnvelopeIdOfReceiver();
+            var receiverDoc = await mediator.Send(new ReadDocumentQuery { EnvelopeId = envelopeId }, cancel);
+            return receiverDoc.ByteData is byte[] receiverDocByte
+                ? File(receiverDocByte, "application/octet-stream")
+                : NotFound("Document is empty.");
+        }
+
+        return Unauthorized();
+    }
+}

EnvelopeGenerator.API/Controllers/EmailTemplateController.cs

@@ -0,0 +1,77 @@
+using AutoMapper;
+using EnvelopeGenerator.Application.EmailTemplates.Commands;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using MediatR;
+using EnvelopeGenerator.Application.Common.Dto;
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Domain.Entities;
+using Microsoft.EntityFrameworkCore;
+using EnvelopeGenerator.Domain.Constants;
+using EnvelopeGenerator.Application.EmailTemplates.Queries;
+
+namespace EnvelopeGenerator.API.Controllers;
+
+/// <summary>
+/// Controller for managing temp templates.
+/// Steuerung zur Verwaltung von E-Mail-Vorlagen.
+/// </summary>
+/// <remarks>
+/// Initialisiert eine neue Instanz der <see cref="EmailTemplateController"/>-Klasse.
+/// </remarks>
+/// <param name="mapper">
+/// <param name="repository">
+/// Die AutoMapper-Instanz, die zum Zuordnen von Objekten verwendet wird.
+/// </param>
+[Route("api/[controller]")]
+[ApiController]
+[Authorize(Policy = AuthPolicy.Sender)]
+public class EmailTemplateController(IMapper mapper, IRepository<EmailTemplate> repository, IMediator mediator) : ControllerBase
+{
+    /// <summary>
+    /// Ruft E-Mail-Vorlagen basierend auf der angegebenen Abfrage ab.
+    /// Gibt alles zurück, wenn keine Id- oder Typ-Informationen eingegeben wurden.
+    /// </summary>
+    /// <param name="emailTemplate">Die Abfrageparameter zum Abrufen von E-Mail-Vorlagen.</param>
+    /// <returns>Gibt HTTP-Antwort zurück</returns>
+    /// <remarks>
+    /// Sample request:
+    /// GET /api/EmailTemplate?emailTemplateId=123
+    /// </remarks>
+    /// <response code="200">Wenn die E-Mail-Vorlagen erfolgreich abgerufen werden.</response>
+    /// <response code="400">Wenn die Abfrageparameter ungültig sind.</response>
+    /// <response code="401">Wenn der Benutzer nicht authentifiziert ist.</response>
+    /// <response code="404">Wenn die gesuchte Abfrage nicht gefunden wird.</response>
+    [HttpGet]
+    public async Task<IActionResult> Get([FromQuery] ReadEmailTemplateQuery? emailTemplate = null)
+    {
+        if (emailTemplate is null || (emailTemplate.Id is null && emailTemplate.Type is null))
+        {
+            var temps = await repository.Query.ToListAsync();
+            return Ok(mapper.Map<IEnumerable<EmailTemplateDto>>(temps));
+        }
+        else
+        {
+            var temp = await mediator.Send(emailTemplate);
+            return temp is null ? NotFound() : Ok(temp);
+        }
+    }
+
+    /// <summary>
+    /// Updates an temp template or resets it if no update command is provided.
+    /// Aktualisiert eine E-Mail-Vorlage oder setzt sie zurück, wenn kein Aktualisierungsbefehl angegeben ist.
+    /// </summary>
+    /// <param name="update"></param>
+    /// <param name="cancel"></param>
+    /// <returns></returns>
+    /// <response code="200">Wenn die E-Mail-Vorlage erfolgreich aktualisiert oder zurückgesetzt wird.</response>
+    /// <response code="400">Wenn die Abfrage ohne einen String gesendet wird.</response>
+    /// <response code="401">Wenn der Benutzer nicht authentifiziert ist.</response>
+    /// <response code="404">Wenn die gesuchte Abfrage nicht gefunden wird.</response>
+    [HttpPut]
+    public async Task<IActionResult> Update([FromBody] UpdateEmailTemplateCommand update, CancellationToken cancel)
+    {
+        await mediator.Send(update, cancel);
+        return Ok();
+    }
+}

EnvelopeGenerator.API/Controllers/EnvelopeController.cs

@@ -0,0 +1,111 @@
+using EnvelopeGenerator.API.Extensions;
+using EnvelopeGenerator.Application.Envelopes.Commands;
+using EnvelopeGenerator.Application.Envelopes.Queries;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Newtonsoft.Json;
+
+namespace EnvelopeGenerator.API.Controllers;
+
+/// <summary>
+/// Dieser Controller stellt Endpunkte für die Verwaltung von Umschlägen bereit.
+/// </summary>
+/// <remarks>
+/// Die API ermöglicht das Abrufen und Verwalten von Umschlägen basierend auf Benutzerinformationen und Statusfiltern.
+/// 
+/// Mögliche Antworten:
+/// - 200 OK: Die Anfrage war erfolgreich, und die angeforderten Daten werden zurückgegeben.
+/// - 400 Bad Request: Die Anfrage war fehlerhaft oder unvollständig.
+/// - 401 Unauthorized: Der Benutzer ist nicht authentifiziert.
+/// - 403 Forbidden: Der Benutzer hat keine Berechtigung, auf die Ressource zuzugreifen.
+/// - 404 Not Found: Die angeforderte Ressource wurde nicht gefunden.
+/// - 500 Internal Server Error: Ein unerwarteter Fehler ist aufgetreten.
+/// </remarks>
+[Route("api/[controller]")]
+[ApiController]
+[Authorize]
+public class EnvelopeController : ControllerBase
+{
+    private readonly ILogger<EnvelopeController> _logger;
+    private readonly IMediator _mediator;
+
+    /// <summary>
+    /// Erstellt eine neue Instanz des EnvelopeControllers.
+    /// </summary>
+    /// <param name="logger">Der Logger, der für das Protokollieren von Informationen verwendet wird.</param>
+    /// <param name="mediator"></param>
+    public EnvelopeController(ILogger<EnvelopeController> logger, IMediator mediator)
+    {
+        _logger = logger;
+        _mediator = mediator;
+    }
+
+    /// <summary>
+    /// Ruft eine Liste von Umschlägen basierend auf dem Benutzer und den angegebenen Statusfiltern ab.
+    /// </summary>
+    /// <param name="envelope"></param>
+    /// <returns>Eine IActionResult-Instanz, die die abgerufenen Umschläge oder einen Fehlerstatus enthält.</returns>
+    /// <response code="200">Die Anfrage war erfolgreich, und die Umschläge werden zurückgegeben.</response>
+    /// <response code="400">Die Anfrage war fehlerhaft oder unvollständig.</response>
+    /// <response code="401">Der Benutzer ist nicht authentifiziert.</response>
+    /// <response code="403">Der Benutzer hat keine Berechtigung, auf die Ressource zuzugreifen.</response>
+    /// <response code="500">Ein unerwarteter Fehler ist aufgetreten.</response>
+    [Authorize]
+    [HttpGet]
+    public async Task<IActionResult> GetAsync([FromQuery] ReadEnvelopeQuery envelope)
+    {
+        var result = await _mediator.Send(envelope.Authorize(User.GetId()));
+        return result.Any() ? Ok(result) : NotFound();
+    }
+
+    /// <summary>
+    /// Ruft das Ergebnis eines Dokuments basierend auf der ID ab.
+    /// </summary>
+    /// <param name="query"></param>
+    /// <param name="view">Gibt an, ob das Dokument inline angezeigt werden soll (true) oder als Download bereitgestellt wird (false).</param>
+    /// <returns>Eine IActionResult-Instanz, die das Dokument oder einen Fehlerstatus enthält.</returns>
+    /// <response code="200">Das Dokument wurde erfolgreich abgerufen.</response>
+    /// <response code="404">Das Dokument wurde nicht gefunden oder ist nicht verfügbar.</response>
+    /// <response code="500">Ein unerwarteter Fehler ist aufgetreten.</response>
+    [HttpGet("doc-result")]
+    public async Task<IActionResult> GetDocResultAsync([FromQuery] ReadEnvelopeQuery query, [FromQuery] bool view = false)
+    {
+        var envelopes = await _mediator.Send(query.Authorize(User.GetId()));
+        var envelope = envelopes.FirstOrDefault();
+
+        if (envelope is null)
+            return NotFound("Envelope not available.");
+        if (envelope.DocResult is null)
+            return NotFound("The document has not been fully signed or the result has not yet been released.");
+
+        if (view)
+        {
+            Response.Headers.Append("Content-Disposition", "inline; filename=\"" + envelope.Uuid + ".pdf\"");
+            return File(envelope.DocResult, "application/pdf");
+        }
+
+        return File(envelope.DocResult, "application/pdf", $"{envelope.Uuid}.pdf");
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="command"></param>
+    /// <returns></returns>
+    [NonAction]
+    [Authorize]
+    [HttpPost]
+    public async Task<IActionResult> CreateAsync([FromBody] CreateEnvelopeCommand command)
+    {
+        var res = await _mediator.Send(command.Authorize(User.GetId()));
+
+        if (res is null)
+        {
+            _logger.LogError("Failed to create envelope. Envelope details: {EnvelopeDetails}", JsonConvert.SerializeObject(command));
+            return StatusCode(StatusCodes.Status500InternalServerError);
+        }
+        else
+            return Ok(res);
+    }
+}

EnvelopeGenerator.API/Controllers/EnvelopeReceiverController.cs

@@ -1,25 +1,21 @@
 using AutoMapper;
-using DigitalData.Core.Abstraction.Application.DTO;
 using EnvelopeGenerator.Application.EnvelopeReceivers.Commands;
 using EnvelopeGenerator.Application.EnvelopeReceivers.Queries;
 using EnvelopeGenerator.Application.Envelopes.Queries;
 using EnvelopeGenerator.Domain.Entities;
-using EnvelopeGenerator.GeneratorAPI.Models;
+using EnvelopeGenerator.API.Models;
 using MediatR;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Data.SqlClient;
 using Microsoft.Extensions.Options;
 using System.Data;
-using System.Reflection.Metadata;
-using EnvelopeGenerator.Domain;
-using EnvelopeGenerator.Domain.Constants;
 using EnvelopeGenerator.Application.Common.SQL;
 using EnvelopeGenerator.Application.Common.Dto.Receiver;
-using EnvelopeGenerator.Application.Common.Interfaces.Services;
 using EnvelopeGenerator.Application.Common.Interfaces.SQLExecutor;
+using EnvelopeGenerator.API.Extensions;
 
-namespace EnvelopeGenerator.GeneratorAPI.Controllers;
+namespace EnvelopeGenerator.API.Controllers;
 
 /// <summary>
 /// Controller für die Verwaltung von Umschlagempfängern.
@@ -33,38 +29,19 @@ namespace EnvelopeGenerator.GeneratorAPI.Controllers;
 public class EnvelopeReceiverController : ControllerBase
 {
     private readonly ILogger<EnvelopeReceiverController> _logger;
-
-    [Obsolete("Use MediatR")]
-    private readonly IEnvelopeReceiverService _erService;
-
     private readonly IMediator _mediator;
-
     private readonly IMapper _mapper;
-
     private readonly IEnvelopeExecutor _envelopeExecutor;
-
     private readonly IEnvelopeReceiverExecutor _erExecutor;
-
     private readonly IDocumentExecutor _documentExecutor;
-
     private readonly string _cnnStr;
 
     /// <summary>
     /// Konstruktor für den EnvelopeReceiverController.
     /// </summary>
-    /// <param name="logger">Logger-Instanz zur Protokollierung von Informationen und Fehlern.</param>
-    /// <param name="envelopeReceiverService">Service zur Verwaltung von Umschlagempfängern.</param>
-    /// <param name="mediator">Mediator-Instanz zur Verarbeitung von Befehlen und Abfragen.</param>
-    /// <param name="mapper"></param>
-    /// <param name="envelopeExecutor"></param>
-    /// <param name="erExecutor"></param>
-    /// <param name="documentExecutor"></param>
-    /// <param name="csOpt"></param>
-    [Obsolete("Use MediatR")]
-    public EnvelopeReceiverController(ILogger<EnvelopeReceiverController> logger, IEnvelopeReceiverService envelopeReceiverService, IMediator mediator, IMapper mapper, IEnvelopeExecutor envelopeExecutor, IEnvelopeReceiverExecutor erExecutor, IDocumentExecutor documentExecutor, IOptions<ConnectionString> csOpt)
+    public EnvelopeReceiverController(ILogger<EnvelopeReceiverController> logger, IMediator mediator, IMapper mapper, IEnvelopeExecutor envelopeExecutor, IEnvelopeReceiverExecutor erExecutor, IDocumentExecutor documentExecutor, IOptions<ConnectionString> csOpt)
     {
         _logger = logger;
-        _erService = envelopeReceiverService;
         _mediator = mediator;
         _mapper = mapper;
         _envelopeExecutor = envelopeExecutor;
@@ -87,32 +64,13 @@ public class EnvelopeReceiverController : ControllerBase
     /// <response code="500">Ein unerwarteter Fehler ist aufgetreten.</response>
     [Authorize]
     [HttpGet]
-    [Obsolete("Use MediatR")]
     public async Task<IActionResult> GetEnvelopeReceiver([FromQuery] ReadEnvelopeReceiverQuery envelopeReceiver)
     {
-        var username = User.GetUsernameOrDefault();
+        envelopeReceiver = envelopeReceiver with { Username = User.GetUsername() };
 
-        if (username is null)
-        {
-            _logger.LogError(@"Envelope Receiver dto cannot be sent because username claim is null. Potential authentication and authorization error. The value of other claims are [id: {id}], [username: {username}], [name: {name}], [prename: {prename}], [email: {email}].",
-                User.GetId(), User.GetUsernameOrDefault(), User.GetNameOrDefault(), User.GetPrenameOrDefault(), User.GetEmailOrDefault());
-            return StatusCode(StatusCodes.Status500InternalServerError);
-        }
+        var result = await _mediator.Send(envelopeReceiver);
 
-        return await _erService.ReadByUsernameAsync(
-            username: username,
-            min_status: envelopeReceiver.Envelope.Status?.Min,
-            max_status: envelopeReceiver.Envelope.Status?.Max,
-            envelopeQuery: envelopeReceiver.Envelope,
-            receiverQuery: envelopeReceiver.Receiver,
-            ignore_statuses: envelopeReceiver.Envelope.Status?.Ignore ?? Array.Empty<EnvelopeStatus>())
-            .ThenAsync(
-                Success: Ok,
-                Fail: IActionResult (msg, ntc) =>
-                {
-                    _logger.LogNotice(ntc);
-                    return StatusCode(StatusCodes.Status500InternalServerError, msg);
-                });
+        return Ok(result);
     }
 
     /// <summary>
@@ -129,25 +87,17 @@ public class EnvelopeReceiverController : ControllerBase
     /// <response code="500">Ein unerwarteter Fehler ist aufgetreten.</response>
     [Authorize]
     [HttpGet("salute")]
-    [Obsolete("Use MediatR")]
     public async Task<IActionResult> GetReceiverName([FromQuery] ReadReceiverNameQuery receiver)
     {
-        return await _erService.ReadLastUsedReceiverNameByMailAsync(receiver.EmailAddress, receiver.Id, receiver.Signature).ThenAsync(
-                        Success: res => res is null ? NotFound() : Ok(res),
-                        Fail: IActionResult (msg, ntc) =>
-                        {
-                            if (ntc.HasFlag(Flag.NotFound))
-                                return NotFound();
-
-                            _logger.LogNotice(ntc);
-                            return StatusCode(StatusCodes.Status500InternalServerError);
-                        });
+        var name = await _mediator.Send(receiver);
+        return name is null ? NotFound() : Ok(name);
     }
 
     /// <summary>
     /// Datenübertragungsobjekt mit Informationen zu Umschlägen, Empfängern und Unterschriften.
     /// </summary>
     /// <param name="request"></param>
+    /// <param name="cancel"></param>
     /// <returns>HTTP-Antwort</returns>
     /// <remarks>
     /// Sample request:
@@ -183,13 +133,10 @@ public class EnvelopeReceiverController : ControllerBase
     /// <response code="500">Es handelt sich um einen unerwarteten Fehler. Die Protokolle sollten überprüft werden.</response>
     [Authorize]
     [HttpPost]
-    public async Task<IActionResult> CreateAsync([FromBody] CreateEnvelopeReceiverCommand request)
+    public async Task<IActionResult> CreateAsync([FromBody] CreateEnvelopeReceiverCommand request, CancellationToken cancel)
     {
-        CancellationToken cancel = default;
-        int userId = User.GetId();
-
         #region Create Envelope
-        var envelope = await _envelopeExecutor.CreateEnvelopeAsync(userId, request.Title, request.Message, request.TFAEnabled, cancel);
+        var envelope = await _envelopeExecutor.CreateEnvelopeAsync(User.GetId(), request.Title, request.Message, request.TFAEnabled, cancel);
         #endregion
 
         #region Add receivers
@@ -270,18 +217,14 @@ public class EnvelopeReceiverController : ControllerBase
         using (SqlConnection conn = new(_cnnStr))
         {
             conn.Open();
-            var formattedSQL_hist = string.Format(sql_hist, envelope.Uuid.ToSqlParam(), 1003.ToSqlParam(), userId.ToSqlParam());
-            using (SqlCommand cmd = new SqlCommand(formattedSQL_hist, conn))
-            {
-                cmd.CommandType = CommandType.Text;
+            var formattedSQL_hist = string.Format(sql_hist, envelope.Uuid.ToSqlParam(), 1003.ToSqlParam(), User.GetId().ToSqlParam());
+            using SqlCommand cmd = new(formattedSQL_hist, conn);
+            cmd.CommandType = CommandType.Text;
 
-                using (SqlDataReader reader = cmd.ExecuteReader())
-                {
-                    if (reader.Read())
-                    {
-                        bool outSuccess = reader.GetBoolean(0);
-                    }
-                }
+            using SqlDataReader reader = cmd.ExecuteReader();
+            if (reader.Read())
+            {
+                bool outSuccess = reader.GetBoolean(0);
             }
         }
         #endregion

EnvelopeGenerator.API/Controllers/EnvelopeTypeController.cs

@@ -0,0 +1,39 @@
+using MediatR;
+using EnvelopeGenerator.Application.EnvelopeTypes.Queries;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.GeneratorAPI.Controllers;
+
+/// <summary>
+/// 
+/// </summary>
+[ApiExplorerSettings(IgnoreApi = true)]
+[Route("api/[controller]")]
+[ApiController]
+public class EnvelopeTypeController : ControllerBase
+{
+    private readonly ILogger<EnvelopeTypeController> _logger;
+    private readonly IMediator _mediator;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="logger"></param>
+    /// <param name="mediator"></param>
+    public EnvelopeTypeController(ILogger<EnvelopeTypeController> logger, IMediator mediator)
+    {
+        _logger = logger;
+        _mediator = mediator;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <returns></returns>
+    [HttpGet]
+    public async Task<IActionResult> GetAllAsync()
+    {
+        var result = await _mediator.Send(new ReadEnvelopeTypesQuery());
+        return Ok(result);
+    }
+}

EnvelopeGenerator.API/Controllers/HistoryController.cs

@@ -6,7 +6,7 @@ using EnvelopeGenerator.Application.Histories.Queries;
 using EnvelopeGenerator.Domain.Constants;
 using EnvelopeGenerator.Application.Common.Extensions;
 
-namespace EnvelopeGenerator.GeneratorAPI.Controllers;
+namespace EnvelopeGenerator.API.Controllers;
 
 /// <summary>
 /// Dieser Controller stellt Endpunkte für den Zugriff auf die Umschlaghistorie bereit.
@@ -113,6 +113,6 @@ public class HistoryController : ControllerBase
     public async Task<IActionResult> GetAllAsync([FromQuery] ReadHistoryQuery historyQuery, CancellationToken cancel)
     {
         var history = await _mediator.Send(historyQuery, cancel).ThrowIfEmpty(Exceptions.NotFound);
-        return Ok((historyQuery.OnlyLast ?? false) ? history.MaxBy(h => h.AddedWhen) : history);
+        return Ok((historyQuery.OnlyLast) ? history.MaxBy(h => h.AddedWhen) : history);
     }
 }

EnvelopeGenerator.API/Controllers/Interfaces/IAuthController.cs

@@ -0,0 +1,38 @@
+using System.Security.Claims;
+using Microsoft.AspNetCore.Authorization;
+
+namespace EnvelopeGenerator.API.Controllers.Interfaces;
+
+/// <summary>
+/// 
+/// </summary>
+public interface IAuthController
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    IAuthorizationService AuthService { get; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    ClaimsPrincipal User { get; }
+}
+
+/// <summary>
+/// 
+/// </summary>
+public static class AuthControllerExtensions
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="controller"></param>
+    /// <param name="policyName"></param>
+    /// <returns></returns>
+    public static async Task<bool> IsUserInPolicyAsync(this IAuthController controller, string policyName)
+    {
+        var result = await controller.AuthService.AuthorizeAsync(controller.User, policyName);
+        return result.Succeeded;
+    }
+}

EnvelopeGenerator.API/Controllers/LocalizationController.cs

@@ -1,12 +1,12 @@
 using DigitalData.Core.API;
 using EnvelopeGenerator.Application.Resources;
-using EnvelopeGenerator.CommonServices;
 using Microsoft.AspNetCore.Localization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Localization;
+using EnvelopeGenerator.Application.Resources;
 
-namespace EnvelopeGenerator.GeneratorAPI.Controllers;
+namespace EnvelopeGenerator.API.Controllers;
 
 /// <summary>
 /// Controller für die Verwaltung der Lokalisierung und Spracheinstellungen.
@@ -19,7 +19,7 @@ public class LocalizationController : ControllerBase
     private static readonly Guid L_KEY = Guid.NewGuid();
 
     private readonly ILogger<LocalizationController> _logger;
-    private readonly IStringLocalizer<Model> _mLocalizer;
+    private readonly IStringLocalizer<Resource> _mLocalizer;
     private readonly IStringLocalizer<Resource> _localizer;
     private readonly IMemoryCache _cache;
 
@@ -34,7 +34,7 @@ public class LocalizationController : ControllerBase
         ILogger<LocalizationController> logger,
         IStringLocalizer<Resource> localizer,
         IMemoryCache memoryCache,
-        IStringLocalizer<Model> _modelLocalizer)
+        IStringLocalizer<Resource> _modelLocalizer)
     {
         _logger = logger;
         _localizer = localizer;

EnvelopeGenerator.API/Controllers/ReadOnlyController.cs

@@ -0,0 +1,90 @@
+using DigitalData.Core.Abstraction.Application.DTO;
+using EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiverReadOnly;
+using EnvelopeGenerator.Application.Common.Interfaces.Services;
+using EnvelopeGenerator.Domain.Constants;
+using EnvelopeGenerator.API.Extensions;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Newtonsoft.Json;
+
+namespace EnvelopeGenerator.API.Controllers;
+
+/// <summary>
+/// Manages read-only envelope sharing flows.
+/// </summary>
+[Route("api/[controller]")]
+[ApiController]
+public class ReadOnlyController : ControllerBase
+{
+    private readonly ILogger<ReadOnlyController> _logger;
+    private readonly IEnvelopeReceiverReadOnlyService _readOnlyService;
+    private readonly IEnvelopeMailService _mailService;
+    private readonly IEnvelopeHistoryService _historyService;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ReadOnlyController"/> class.
+    /// </summary>
+    public ReadOnlyController(ILogger<ReadOnlyController> logger, IEnvelopeReceiverReadOnlyService readOnlyService, IEnvelopeMailService mailService, IEnvelopeHistoryService historyService)
+    {
+        _logger = logger;
+        _readOnlyService = readOnlyService;
+        _mailService = mailService;
+        _historyService = historyService;
+    }
+
+    /// <summary>
+    /// Creates a new read-only receiver for the current envelope.
+    /// </summary>
+    /// <param name="createDto">Creation payload.</param>
+    [HttpPost]
+    [Authorize(Policy = AuthPolicy.Receiver)]
+    public async Task<IActionResult> CreateAsync([FromBody] EnvelopeReceiverReadOnlyCreateDto createDto)
+    {
+        var authReceiverMail = User.GetReceiverMailOfReceiver();
+        if (authReceiverMail is null)
+        {
+            _logger.LogError("EmailAddress claim is not found in envelope-receiver-read-only creation process. Create DTO is:\n {dto}", JsonConvert.SerializeObject(createDto));
+            return Unauthorized();
+        }
+
+        var envelopeId = User.GetEnvelopeIdOfReceiver();
+
+        createDto.AddedWho = authReceiverMail;
+        createDto.EnvelopeId = envelopeId;
+
+        var creationRes = await _readOnlyService.CreateAsync(createDto: createDto);
+
+        if (creationRes.IsFailed)
+        {
+            _logger.LogNotice(creationRes);
+            return StatusCode(StatusCodes.Status500InternalServerError);
+        }
+
+        var readRes = await _readOnlyService.ReadByIdAsync(creationRes.Data.Id);
+        if (readRes.IsFailed)
+        {
+            _logger.LogNotice(creationRes);
+            return StatusCode(StatusCodes.Status500InternalServerError);
+        }
+
+        var newReadOnly = readRes.Data;
+
+        return await _mailService.SendAsync(newReadOnly).ThenAsync<int, IActionResult>(SuccessAsync: async _ =>
+        {
+            var histRes = await _historyService.RecordAsync((int)createDto.EnvelopeId, createDto.AddedWho, EnvelopeStatus.EnvelopeShared);
+            if (histRes.IsFailed)
+            {
+                _logger.LogError("Although the envelope was sent as read-only, the EnvelopeShared history could not be saved. Create DTO:\n{createDto}", JsonConvert.SerializeObject(createDto));
+                _logger.LogNotice(histRes.Notices);
+            }
+
+            return Ok();
+        },
+
+        Fail: (msg, ntc) =>
+        {
+            _logger.LogNotice(ntc);
+            return StatusCode(StatusCodes.Status500InternalServerError);
+        });
+    }
+}

EnvelopeGenerator.API/Controllers/ReceiverController.cs

@@ -0,0 +1,47 @@
+using MediatR;
+using EnvelopeGenerator.Application.Receivers.Queries;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.GeneratorAPI.Controllers;
+
+/// <summary>
+/// Controller für die Verwaltung von Empfängern.
+/// </summary>
+/// <remarks>
+/// Dieser Controller bietet Endpunkte für das Abrufen von Empfängern basierend auf E-Mail-Adresse oder Signatur.
+/// </remarks>
+[Route("api/[controller]")]
+[ApiController]
+[Authorize]
+public class ReceiverController : ControllerBase
+{
+    private readonly IMediator _mediator;
+
+    /// <summary>
+    /// Initialisiert eine neue Instanz des <see cref="ReceiverController"/>-Controllers.
+    /// </summary>
+    /// <param name="mediator">Mediator für Anfragen.</param>
+    public ReceiverController(IMediator mediator)
+    {
+        _mediator = mediator;
+    }
+
+    /// <summary>
+    /// Ruft eine Liste von Empfängern ab, basierend auf den angegebenen Abfrageparametern.
+    /// </summary>
+    /// <param name="receiver">Die Abfrageparameter, einschließlich E-Mail-Adresse und Signatur.</param>
+    /// <returns>Eine Liste von Empfängern oder ein Fehlerstatus.</returns>
+    [HttpGet]
+    public async Task<IActionResult> Get([FromQuery] ReadReceiverQuery receiver)
+    {
+        if (!receiver.HasAnyCriteria)
+        {
+            var all = await _mediator.Send(new ReadReceiverQuery());
+            return Ok(all);
+        }
+
+        var result = await _mediator.Send(receiver);
+        return result is null ? NotFound() : Ok(result);
+    }
+}

EnvelopeGenerator.API/Controllers/TfaRegistrationController.cs

@@ -0,0 +1,129 @@
+using DigitalData.Core.Abstraction.Application.DTO;
+using EnvelopeGenerator.Application.Common.Extensions;
+using EnvelopeGenerator.Application.Common.Interfaces.Services;
+using EnvelopeGenerator.Application.Resources;
+using EnvelopeGenerator.Domain.Constants;
+using EnvelopeGenerator.API.Models;
+using Ganss.Xss;
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Authentication.Cookies;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Localization;
+using Microsoft.Extensions.Options;
+
+namespace EnvelopeGenerator.API.Controllers;
+
+/// <summary>
+/// Exposes endpoints for registering and managing two-factor authentication for envelope receivers.
+/// </summary>
+[ApiController]
+[Route("api/tfa")]
+public class TfaRegistrationController : ControllerBase
+{
+    private readonly ILogger<TfaRegistrationController> _logger;
+    private readonly IEnvelopeReceiverService _envelopeReceiverService;
+    private readonly IAuthenticator _authenticator;
+    private readonly IReceiverService _receiverService;
+    private readonly TFARegParams _parameters;
+    private readonly IStringLocalizer<Resource> _localizer;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="TfaRegistrationController"/> class.
+    /// </summary>
+    public TfaRegistrationController(
+        ILogger<TfaRegistrationController> logger,
+        IEnvelopeReceiverService envelopeReceiverService,
+        IAuthenticator authenticator,
+        IReceiverService receiverService,
+        IOptions<TFARegParams> tfaRegParamsOptions,
+        IStringLocalizer<Resource> localizer)
+    {
+        _logger = logger;
+        _envelopeReceiverService = envelopeReceiverService;
+        _authenticator = authenticator;
+        _receiverService = receiverService;
+        _parameters = tfaRegParamsOptions.Value;
+        _localizer = localizer;
+    }
+
+    /// <summary>
+    /// Generates registration metadata (QR code and deadline) for a receiver.
+    /// </summary>
+    /// <param name="envelopeReceiverId">Encoded envelope receiver id.</param>
+    [Authorize]
+    [HttpGet("{envelopeReceiverId}")]
+    public async Task<IActionResult> RegisterAsync(string envelopeReceiverId)
+    {
+        try
+        {
+            var (uuid, signature) = envelopeReceiverId.DecodeEnvelopeReceiverId();
+
+            if (uuid is null || signature is null)
+            {
+                _logger.LogEnvelopeError(uuid: uuid, signature: signature, message: _localizer.WrongEnvelopeReceiverId());
+                return Unauthorized(new { message = _localizer.WrongEnvelopeReceiverId() });
+            }
+
+            var secretResult = await _envelopeReceiverService.ReadWithSecretByUuidSignatureAsync(uuid: uuid, signature: signature);
+            if (secretResult.IsFailed)
+            {
+                _logger.LogNotice(secretResult.Notices);
+                return NotFound(new { message = _localizer.WrongEnvelopeReceiverId() });
+            }
+
+            var envelopeReceiver = secretResult.Data;
+
+            if (!envelopeReceiver.Envelope!.TFAEnabled)
+                return Unauthorized(new { message = _localizer.WrongAccessCode() });
+
+            var receiver = envelopeReceiver.Receiver;
+            receiver!.TotpSecretkey = _authenticator.GenerateTotpSecretKey();
+            await _receiverService.UpdateAsync(receiver);
+            var totpQr64 = _authenticator.GenerateTotpQrCode(userEmail: receiver.EmailAddress, secretKey: receiver.TotpSecretkey).ToBase64String();
+
+            if (receiver.TfaRegDeadline is null)
+            {
+                receiver.TfaRegDeadline = _parameters.Deadline;
+                await _receiverService.UpdateAsync(receiver);
+            }
+            else if (receiver.TfaRegDeadline <= DateTime.Now)
+            {
+                return StatusCode(StatusCodes.Status410Gone, new { message = _localizer.WrongAccessCode() });
+            }
+
+            return Ok(new
+            {
+                envelopeReceiver.EnvelopeId,
+                envelopeReceiver.Envelope!.Uuid,
+                envelopeReceiver.Receiver!.Signature,
+                receiver.TfaRegDeadline,
+                TotpQR64 = totpQr64
+            });
+        }
+        catch (Exception ex)
+        {
+            _logger.LogEnvelopeError(envelopeReceiverId: envelopeReceiverId, exception: ex, message: _localizer.WrongEnvelopeReceiverId());
+            return StatusCode(StatusCodes.Status500InternalServerError, new { message = _localizer.UnexpectedError() });
+        }
+    }
+
+    /// <summary>
+    /// Logs out the envelope receiver from cookie authentication.
+    /// </summary>
+    [Authorize(Policy = AuthPolicy.Receiver)]
+    [HttpPost("auth/logout")]
+    public async Task<IActionResult> LogOutAsync()
+    {
+        try
+        {
+            await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
+            return Ok();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "{message}", ex.Message);
+            return StatusCode(StatusCodes.Status500InternalServerError, new { message = _localizer.UnexpectedError() });
+        }
+    }
+}

EnvelopeGenerator.API/Documentation/AuthProxyDocumentFilter.cs

@@ -0,0 +1,70 @@
+using EnvelopeGenerator.API.Models;
+using Microsoft.OpenApi.Any;
+using Microsoft.OpenApi.Models;
+using Swashbuckle.AspNetCore.SwaggerGen;
+
+namespace EnvelopeGenerator.API.Documentation;
+
+/// <summary>
+/// 
+/// </summary>
+public sealed class AuthProxyDocumentFilter : IDocumentFilter
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="swaggerDoc"></param>
+    /// <param name="context"></param>
+    public void Apply(OpenApiDocument swaggerDoc, DocumentFilterContext context)
+    {
+        const string path = "/api/auth";
+
+        var loginSchema = context.SchemaGenerator.GenerateSchema(typeof(Login), context.SchemaRepository);
+        var loginExample = new OpenApiObject
+        {
+            ["password"] = new OpenApiString(""),
+            ["username"] = new OpenApiString("")
+        };
+
+        var operation = new OpenApiOperation
+        {
+            Summary = "Proxy login (auth-hub)",
+            Description = "Proxies the request to the auth service. Add query parameter `cookie=true|false`.",
+            Tags = [new() { Name = "Auth" }],
+            Parameters =
+            {
+                new OpenApiParameter
+                {
+                    Name = "cookie",
+                    In = ParameterLocation.Query,
+                    Required = false,
+                    Schema = new OpenApiSchema { Type = "boolean", Default = new OpenApiBoolean(true) },
+                    Example = new OpenApiBoolean(true),
+                    Description = "If true, auth service sets the auth cookie."
+                }
+            },
+            RequestBody = new OpenApiRequestBody
+            {
+                Required = true,
+                Content =
+                {
+                    ["application/json"] = new OpenApiMediaType { Schema = loginSchema, Example = loginExample },
+                    ["multipart/form-data"] = new OpenApiMediaType { Schema = loginSchema, Example = loginExample }
+                }
+            },
+            Responses =
+            {
+                ["200"] = new OpenApiResponse { Description = "OK (proxied response)" },
+                ["401"] = new OpenApiResponse { Description = "Unauthorized" }
+            }
+        };
+
+        swaggerDoc.Paths[path] = new OpenApiPathItem
+        {
+            Operations =
+            {
+                [OperationType.Post] = operation
+            }
+        };
+    }
+}

EnvelopeGenerator.API/EnvelopeClaimTypes.cs

@@ -0,0 +1,17 @@
+namespace EnvelopeGenerator.API;
+
+/// <summary>
+/// Provides custom claim types for envelope-related information.
+/// </summary>
+public static class EnvelopeClaimTypes
+{
+    /// <summary>
+    /// Claim type for the title of an envelope.
+    /// </summary>
+    public static readonly string Title = $"Envelope{nameof(Title)}";
+
+    /// <summary>
+    /// Claim type for the ID of an envelope.
+    /// </summary>
+    public static readonly string Id = $"Envelope{nameof(Id)}";
+}

EnvelopeGenerator.API/EnvelopeGenerator.API.csproj

@@ -17,6 +17,17 @@
 	<DocumentationFile>bin\$(Configuration)\$(TargetFramework)\$(AssemblyName).xml</DocumentationFile>
   </PropertyGroup>
 
+  <ItemGroup>
+    <Compile Remove="ClientApp\**" />
+    <Content Remove="ClientApp\**" />
+    <EmbeddedResource Remove="ClientApp\**" />
+    <None Remove="ClientApp\**" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="yarp.json" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="AspNetCore.Scalar" Version="1.1.8" />
     <PackageReference Include="DigitalData.Auth.Client" Version="1.3.7" />
@@ -28,6 +39,7 @@
     <PackageReference Include="Scalar.AspNetCore" Version="2.2.1" />
     <PackageReference Include="Swashbuckle.AspNetCore" Version="8.1.1" />
     <PackageReference Include="DigitalData.EmailProfilerDispatcher.Abstraction" Version="3.2.0" />
+    <PackageReference Include="Yarp.ReverseProxy" Version="2.1.0" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)' == 'net7.0'">
@@ -49,41 +61,13 @@
   </ItemGroup>
 
   <ItemGroup>
-    <Folder Include="ClientApp\" />
+    <Folder Include="wwwroot\" />
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\EnvelopeGenerator.Application\EnvelopeGenerator.Application.csproj" />
-    <ProjectReference Include="..\EnvelopeGenerator.CommonServices\EnvelopeGenerator.CommonServices.vbproj" />
     <ProjectReference Include="..\EnvelopeGenerator.Domain\EnvelopeGenerator.Domain.csproj" />
     <ProjectReference Include="..\EnvelopeGenerator.Infrastructure\EnvelopeGenerator.Infrastructure.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <None Update="ClientApp\envelope-generator-ui\dist\envelope-generator-ui\browser\chunk-35PBLQEP.js">
-      <CopyToOutputDirectory>Never</CopyToOutputDirectory>
-    </None>
-    <None Update="ClientApp\envelope-generator-ui\dist\envelope-generator-ui\browser\chunk-IUSOII6E.js">
-      <CopyToOutputDirectory>Never</CopyToOutputDirectory>
-    </None>
-    <None Update="ClientApp\envelope-generator-ui\dist\envelope-generator-ui\browser\favicon.ico">
-      <CopyToOutputDirectory>Never</CopyToOutputDirectory>
-    </None>
-    <None Update="ClientApp\envelope-generator-ui\dist\envelope-generator-ui\browser\index.html">
-      <CopyToOutputDirectory>Never</CopyToOutputDirectory>
-    </None>
-    <None Update="ClientApp\envelope-generator-ui\dist\envelope-generator-ui\browser\login\index.html">
-      <CopyToOutputDirectory>Never</CopyToOutputDirectory>
-    </None>
-    <None Update="ClientApp\envelope-generator-ui\dist\envelope-generator-ui\browser\main-ZN7C4PGY.js">
-      <CopyToOutputDirectory>Never</CopyToOutputDirectory>
-    </None>
-    <None Update="ClientApp\envelope-generator-ui\dist\envelope-generator-ui\browser\polyfills-N6LQB2YD.js">
-      <CopyToOutputDirectory>Never</CopyToOutputDirectory>
-    </None>
-    <None Update="ClientApp\envelope-generator-ui\dist\envelope-generator-ui\browser\styles-S5ZWIC2V.css">
-      <CopyToOutputDirectory>Never</CopyToOutputDirectory>
-    </None>
-  </ItemGroup>
-
 </Project>

EnvelopeGenerator.API/Extensions/ReceiverClaimExtensions.cs

@@ -0,0 +1,101 @@
+using System.Linq;
+using System.Security.Claims;
+using EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiver;
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Authentication.Cookies;
+
+namespace EnvelopeGenerator.API.Extensions;
+
+/// <summary>
+/// Provides helper methods for working with envelope-specific authentication claims.
+/// </summary>
+public static class ReceiverClaimExtensions
+{
+    private static string GetRequiredClaimOfReceiver(this ClaimsPrincipal user, string claimType)
+    {
+        var value = user.FindFirstValue(claimType);
+        if (value is not null)
+        {
+            return value;
+        }
+
+        var identity = user.Identity;
+        var principalName = identity?.Name ?? "(anonymous)";
+        var authType = identity?.AuthenticationType ?? "(none)";
+        var availableClaims = string.Join(", ", user.Claims.Select(c => $"{c.Type}={c.Value}"));
+        var message = $"Required claim '{claimType}' is missing for user '{principalName}' (auth: {authType}). Available claims: [{availableClaims}].";
+        throw new InvalidOperationException(message);
+    }
+
+    /// <summary>
+    /// Gets the authenticated envelope UUID from the claims.
+    /// </summary>
+    public static string GetEnvelopeUuidOfReceiver(this ClaimsPrincipal user) => user.GetRequiredClaimOfReceiver(ClaimTypes.NameIdentifier);
+
+    /// <summary>
+    /// Gets the authenticated receiver signature from the claims.
+    /// </summary>
+    public static string GetReceiverSignatureOfReceiver(this ClaimsPrincipal user) => user.GetRequiredClaimOfReceiver(ClaimTypes.Hash);
+
+    /// <summary>
+    /// Gets the authenticated receiver display name from the claims.
+    /// </summary>
+    public static string GetReceiverNameOfReceiver(this ClaimsPrincipal user) => user.GetRequiredClaimOfReceiver(ClaimTypes.Name);
+
+    /// <summary>
+    /// Gets the authenticated receiver email address from the claims.
+    /// </summary>
+    public static string GetReceiverMailOfReceiver(this ClaimsPrincipal user) => user.GetRequiredClaimOfReceiver(ClaimTypes.Email);
+
+    /// <summary>
+    /// Gets the authenticated envelope title from the claims.
+    /// </summary>
+    public static string GetEnvelopeTitleOfReceiver(this ClaimsPrincipal user) => user.GetRequiredClaimOfReceiver(EnvelopeClaimTypes.Title);
+
+    /// <summary>
+    /// Gets the authenticated envelope identifier from the claims.
+    /// </summary>
+    public static int GetEnvelopeIdOfReceiver(this ClaimsPrincipal user)
+    {
+        var envIdStr = user.GetRequiredClaimOfReceiver(EnvelopeClaimTypes.Id);
+        if (!int.TryParse(envIdStr, out var envId))
+        {
+            throw new InvalidOperationException($"Claim '{EnvelopeClaimTypes.Id}' is not a valid integer.");
+        }
+
+        return envId;
+    }
+
+    /// <summary>
+    /// Signs in an envelope receiver using cookie authentication and attaches envelope claims.
+    /// </summary>
+    /// <param name="context">The current HTTP context.</param>
+    /// <param name="envelopeReceiver">Envelope receiver DTO to extract claims from.</param>
+    /// <param name="receiverRole">Role to attach to the authentication ticket.</param>
+    public static async Task SignInEnvelopeAsync(this HttpContext context, EnvelopeReceiverDto envelopeReceiver, string receiverRole)
+    {
+        var claims = new List<Claim>
+        {
+            new(ClaimTypes.NameIdentifier, envelopeReceiver.Envelope!.Uuid),
+            new(ClaimTypes.Hash, envelopeReceiver.Receiver!.Signature),
+            new(ClaimTypes.Name, envelopeReceiver.Name ?? string.Empty),
+            new(ClaimTypes.Email, envelopeReceiver.Receiver.EmailAddress),
+            new(EnvelopeClaimTypes.Title, envelopeReceiver.Envelope.Title),
+            new(EnvelopeClaimTypes.Id, envelopeReceiver.Envelope.Id.ToString()),
+            new(ClaimTypes.Role, receiverRole)
+        };
+
+        var claimsIdentity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
+
+        var authProperties = new AuthenticationProperties
+        {
+            AllowRefresh = false,
+            IsPersistent = false
+        };
+
+        await context.SignInAsync(
+            CookieAuthenticationDefaults.AuthenticationScheme,
+            new ClaimsPrincipal(claimsIdentity),
+            authProperties);
+    }
+}

EnvelopeGenerator.API/Extensions/SenderClaimExtensions.cs

@@ -0,0 +1,95 @@
+using System.Security.Claims;
+
+namespace EnvelopeGenerator.API.Extensions
+{
+    /// <summary>
+    /// Provides extension methods for extracting user information from a <see cref="ClaimsPrincipal"/>.
+    /// </summary>
+    public static class SenderClaimExtensions
+    {
+        private static string GetRequiredClaimOfSender(this ClaimsPrincipal user, string claimType)
+        {
+            var value = user.FindFirstValue(claimType);
+            if (value is not null)
+            {
+                return value;
+            }
+
+            var identity = user.Identity;
+            var principalName = identity?.Name ?? "(anonymous)";
+            var authType = identity?.AuthenticationType ?? "(none)";
+            var availableClaims = string.Join(", ", user.Claims.Select(c => $"{c.Type}={c.Value}"));
+            var message = $"Required claim '{claimType}' is missing for user '{principalName}' (auth: {authType}). Available claims: [{availableClaims}].";
+            throw new InvalidOperationException(message);
+        }
+
+        private static string GetRequiredClaimOfSender(this ClaimsPrincipal user, params string[] claimTypes)
+        {
+            string? value = null;
+
+            foreach (var claimType in claimTypes)
+            {
+                value = user.FindFirstValue(claimType);
+                if (value is not null)
+                    return value;
+            }
+
+            var identity = user.Identity;
+            var principalName = identity?.Name ?? "(anonymous)";
+            var authType = identity?.AuthenticationType ?? "(none)";
+            var availableClaims = string.Join(", ", user.Claims.Select(c => $"{c.Type}={c.Value}"));
+            var message = $"Required claim among [{string.Join(", ", claimTypes)}] is missing for user '{principalName}' (auth: {authType}). Available claims: [{availableClaims}].";
+            throw new InvalidOperationException(message);
+        }
+
+        /// <summary>
+        /// Retrieves the user's ID from the claims. Throws an exception if the ID is missing or invalid.
+        /// </summary>
+        /// <param name="user">The <see cref="ClaimsPrincipal"/> representing the user.</param>
+        /// <returns>The user's ID as an integer.</returns>
+        /// <exception cref="InvalidOperationException">Thrown if the user ID claim is missing or invalid.</exception>
+        public static int GetId(this ClaimsPrincipal user)
+        {
+            var idValue = user.GetRequiredClaimOfSender(ClaimTypes.NameIdentifier, "sub");
+
+            if (!int.TryParse(idValue, out var result))
+            {
+                throw new InvalidOperationException("User ID claim is missing or invalid. This may indicate a misconfigured or forged JWT token.");
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Retrieves the username from the claims.
+        /// </summary>
+        /// <param name="user">The <see cref="ClaimsPrincipal"/> representing the user.</param>
+        /// <returns>The username as a string.</returns>
+        public static string GetUsername(this ClaimsPrincipal user)
+            => user.GetRequiredClaimOfSender(ClaimTypes.Name);
+
+        /// <summary>
+        /// Retrieves the user's surname (last name) from the claims.
+        /// </summary>
+        /// <param name="user">The <see cref="ClaimsPrincipal"/> representing the user.</param>
+        /// <returns>The surname as a string.</returns>
+        public static string GetName(this ClaimsPrincipal user)
+            => user.GetRequiredClaimOfSender(ClaimTypes.Surname);
+
+        /// <summary>
+        /// Retrieves the user's given name (first name) from the claims.
+        /// </summary>
+        /// <param name="user">The <see cref="ClaimsPrincipal"/> representing the user.</param>
+        /// <returns>The given name as a string.</returns>
+        public static string GetPrename(this ClaimsPrincipal user)
+            => user.GetRequiredClaimOfSender(ClaimTypes.GivenName);
+
+        /// <summary>
+        /// Retrieves the user's email address from the claims.
+        /// </summary>
+        /// <param name="user">The <see cref="ClaimsPrincipal"/> representing the user.</param>
+        /// <returns>The email address as a string.</returns>
+        public static string GetEmail(this ClaimsPrincipal user)
+            => user.GetRequiredClaimOfSender(ClaimTypes.Email);
+    }
+}

EnvelopeGenerator.API/Middleware/ExceptionHandlingMiddleware.cs

@@ -1,4 +1,4 @@
-namespace EnvelopeGenerator.GeneratorAPI.Middleware;
+namespace EnvelopeGenerator.API.Middleware;
 
 using DigitalData.Core.Exceptions;
 using Microsoft.AspNetCore.Http;

EnvelopeGenerator.API/Models/Auth.cs

@@ -0,0 +1,14 @@
+namespace EnvelopeGenerator.API.Models;
+
+public record Auth(string? AccessCode = null, string? SmsCode = null, string? AuthenticatorCode = null, bool UserSelectSMS = default)
+{
+    public bool HasAccessCode => AccessCode is not null;
+
+    public bool HasSmsCode => SmsCode is not null;
+
+    public bool HasAuthenticatorCode => AuthenticatorCode is not null;
+
+    public bool HasMulti => new[] { HasAccessCode, HasSmsCode, HasAuthenticatorCode }.Count(state => state) > 1;
+
+    public bool HasNone => !(HasAccessCode || HasSmsCode || HasAuthenticatorCode);
+}

EnvelopeGenerator.API/Models/AuthTokenKeys.cs

@@ -1,4 +1,4 @@
-namespace EnvelopeGenerator.GeneratorAPI.Models;
+namespace EnvelopeGenerator.API.Models;
 
 /// <summary>
 /// Represents the keys and default values used for authentication token handling 
@@ -24,5 +24,5 @@ public class AuthTokenKeys
     /// <summary>
     /// Gets the expected audience value for the authentication token.
     /// </summary>
-    public string Audience { get; init; } = "sign-flow-gen.digitaldata.works";
+    public string Audience { get; init; } = "sign-flow.digitaldata.works";
 }

EnvelopeGenerator.API/Models/ConnectionString.cs

@@ -1,4 +1,4 @@
-namespace EnvelopeGenerator.GeneratorAPI.Models;
+namespace EnvelopeGenerator.API.Models;
 
 /// <summary>
 /// 

EnvelopeGenerator.API/Models/ContactLink.cs

@@ -0,0 +1,60 @@
+namespace EnvelopeGenerator.API.Models
+{
+    /// <summary>
+    /// Represents a hyperlink for contact purposes with various HTML attributes.
+    /// </summary>
+    public class ContactLink
+    {
+        /// <summary>
+        /// Gets or sets the label of the hyperlink.
+        /// </summary>
+        public string Label { get; init; } = "Contact";
+
+        /// <summary>
+        /// Gets or sets the URL that the hyperlink points to.
+        /// </summary>
+        public string Href { get; set; } = string.Empty;
+
+        /// <summary>
+        /// Gets or sets the target where the hyperlink should open.
+        /// Commonly used values are "_blank", "_self", "_parent", "_top".
+        /// </summary>
+        public string Target { get; set; } = "_blank";
+
+        /// <summary>
+        /// Gets or sets the relationship of the linked URL as space-separated link types.
+        /// Examples include "nofollow", "noopener", "noreferrer".
+        /// </summary>
+        public string Rel { get; set; } = string.Empty;
+
+        /// <summary>
+        /// Gets or sets the filename that should be downloaded when clicking the hyperlink.
+        /// This attribute will only have an effect if the href attribute is set.
+        /// </summary>
+        public string Download { get; set; } = string.Empty;
+
+        /// <summary>
+        /// Gets or sets the language of the linked resource. Useful when linking to
+        /// content in another language.
+        /// </summary>
+        public string HrefLang { get; set; } = "en";
+
+        /// <summary>
+        /// Gets or sets the MIME type of the linked URL. Helps browsers to handle
+        /// the type correctly when the link is clicked.
+        /// </summary>
+        public string Type { get; set; } = string.Empty;
+
+        /// <summary>
+        /// Gets or sets additional information about the hyperlink, typically viewed
+        /// as a tooltip when the mouse hovers over the link.
+        /// </summary>
+        public string Title { get; set; } = string.Empty;
+
+        /// <summary>
+        /// Gets or sets an identifier for the hyperlink, unique within the HTML document.
+        /// </summary>
+        public string Id { get; set; } = string.Empty;
+    }
+
+}

EnvelopeGenerator.API/Models/Culture.cs

@@ -0,0 +1,17 @@
+using System.Globalization;
+
+namespace EnvelopeGenerator.API.Models;
+
+public class Culture
+{
+    private string _language = string.Empty;
+    public string Language { get => _language;
+        init {
+            _language = value;
+            Info = new(value);
+        } 
+    }
+    public string FIClass { get; init; } = string.Empty;
+
+    public CultureInfo? Info { get; init; }
+}

EnvelopeGenerator.API/Models/Cultures.cs

@@ -0,0 +1,12 @@
+namespace EnvelopeGenerator.API.Models;
+
+public class Cultures : List<Culture>
+{
+    public IEnumerable<string> Languages => this.Select(c => c.Language);
+
+    public IEnumerable<string> FIClasses => this.Select(c => c.FIClass);
+
+    public Culture Default => this.First();
+    
+    public Culture? this[string? language] => language is null ? null : this.Where(c => c.Language == language).FirstOrDefault();
+}

EnvelopeGenerator.API/Models/CustomImages.cs

@@ -0,0 +1,6 @@
+namespace EnvelopeGenerator.API.Models;
+
+public class CustomImages : Dictionary<string, Image>
+{
+    public new Image this[string key] => TryGetValue(key, out var img) && img is not null ? img : new();
+}

EnvelopeGenerator.API/Models/ErrorViewModel.cs

@@ -0,0 +1,10 @@
+namespace EnvelopeGenerator.API.Models;
+
+public class ErrorViewModel
+{
+    public string Title { get; init; } = "404";
+
+    public string Subtitle { get; init; } = "Hmmm...";
+
+    public string Body { get; init; } = "It looks like one of the developers fell asleep";
+}

EnvelopeGenerator.API/Models/Image.cs

@@ -0,0 +1,10 @@
+namespace EnvelopeGenerator.API.Models;
+
+public class Image
+{
+    public string Src { get; init; } = string.Empty;
+
+    public Dictionary<string, string> Classes { get; init; } = new();
+
+    public string GetClassIn(string page) => Classes.TryGetValue(page, out var cls) && cls is not null ? cls : string.Empty;
+}

EnvelopeGenerator.API/Models/Login.cs

@@ -1,6 +1,6 @@
 using System.ComponentModel.DataAnnotations;
 
-namespace EnvelopeGenerator.GeneratorAPI.Models;
+namespace EnvelopeGenerator.API.Models;
 
 /// <summary>
 /// Repräsentiert ein Login-Modell mit erforderlichem Passwort und optionaler ID und Benutzername.

EnvelopeGenerator.API/Models/MainViewModel.cs

@@ -0,0 +1,6 @@
+namespace EnvelopeGenerator.API.Models;
+
+public class MainViewModel
+{
+    public string? Title { get; init; }
+}

EnvelopeGenerator.API/Models/PsPdfKitAnnotation/Annotation.cs

@@ -0,0 +1,93 @@
+using EnvelopeGenerator.API.Models.PsPdfKitAnnotation;
+using System.Text.Json.Serialization;
+
+namespace EnvelopeGenerator.API.Models.PsPdfKitAnnotation;
+
+public record Annotation : IAnnotation
+{
+    public required string Name { get; init; }
+
+    #region Bound Annotation
+    [JsonIgnore]
+    public string? HorBoundAnnotName { get; init; }
+
+    [JsonIgnore]
+    public string? VerBoundAnnotName { get; init; }
+    #endregion
+
+    #region Layout
+    [JsonIgnore]
+    public double? MarginLeft { get; set; }
+
+    [JsonIgnore]
+    public double MarginLeftRatio { get; init; } = 1;
+
+    [JsonIgnore]
+    public double? MarginTop { get; set; }
+
+    [JsonIgnore]
+    public double MarginTopRatio { get; init; } = 1;
+
+    public double? Width { get; set; }
+
+    [JsonIgnore]
+    public double WidthRatio { get; init; } = 1;
+
+    public double? Height { get; set; }
+
+    [JsonIgnore]
+    public double HeightRatio { get; init; } = 1;
+    #endregion
+
+    #region Position
+    public double Left => (MarginLeft ?? 0) + (HorBoundAnnot?.HorBoundary ?? 0);
+
+    public double Top => (MarginTop ?? 0) + (VerBoundAnnot?.VerBoundary ?? 0);
+    #endregion
+
+    #region Boundary
+    [JsonIgnore]
+    public double HorBoundary => Left + (Width ?? 0);
+
+    [JsonIgnore]
+    public double VerBoundary => Top + (Height ?? 0);
+    #endregion
+
+    #region BoundAnnot
+    [JsonIgnore]
+    public Annotation? HorBoundAnnot { get; set; }
+
+    [JsonIgnore]
+    public Annotation? VerBoundAnnot { get; set; }
+    #endregion
+
+    public Color? BackgroundColor { get; init; }
+
+    #region Border
+    public Color? BorderColor { get; init; }
+
+    public string? BorderStyle { get; init; }
+
+    public int? BorderWidth { get; set; }
+    #endregion
+
+    [JsonIgnore]
+    internal Annotation Default 
+    { 
+        set 
+        {
+            // To set null value, annotation must have null (0) value but null must has non-null value
+            if (MarginLeft == null && value.MarginLeft != null)
+                MarginLeft = value.MarginLeft * MarginLeftRatio;
+
+            if (MarginTop == null && value.MarginTop != null)
+                MarginTop = value.MarginTop * MarginTopRatio;
+
+            if (Width == null && value.Width != null)
+                Width = value.Width * WidthRatio;
+
+            if (Height == null && value.Height != null)
+                Height = value.Height * HeightRatio;
+        }
+    }
+};

EnvelopeGenerator.API/Models/PsPdfKitAnnotation/AnnotationParams.cs

@@ -0,0 +1,80 @@
+using EnvelopeGenerator.API.Models.PsPdfKitAnnotation;
+using System.Text.Json.Serialization;
+
+namespace EnvelopeGenerator.API.Models.PsPdfKitAnnotation;
+
+public class AnnotationParams
+{
+    public AnnotationParams()
+    {
+        _AnnotationJSObjectInitor = new(CreateAnnotationJSObject);
+    }
+
+    public Background? Background { get; init; }
+
+    #region Annotation
+    [JsonIgnore]
+    public Annotation? DefaultAnnotation { get; init; }
+
+    private readonly List<Annotation> _annots = new List<Annotation>();
+
+    public bool TryGet(string name, out Annotation annotation)
+    {
+#pragma warning disable CS8601 // Possible null reference assignment.
+        annotation = _annots.FirstOrDefault(a => a.Name == name);
+#pragma warning restore CS8601 // Possible null reference assignment.
+        return annotation is not null;
+    }
+
+    public required IEnumerable<Annotation> Annotations
+    {
+        get => _annots;
+        init
+        {
+            _annots = value.ToList();
+
+            if (DefaultAnnotation is not null)
+                foreach (var annot in _annots)
+                    annot.Default = DefaultAnnotation;
+
+            for (int i = 0; i < _annots.Count; i++)
+            {
+                #region set bound annotations
+                // horizontal
+                if (_annots[i].HorBoundAnnotName is string horBoundAnnotName)
+                    if (TryGet(horBoundAnnotName, out var horBoundAnnot))
+                        _annots[i].HorBoundAnnot = horBoundAnnot;
+                    else
+                        throw new InvalidOperationException($"{horBoundAnnotName} added as bound anotation. However, it is not defined.");
+
+                // vertical
+                if (_annots[i].VerBoundAnnotName is string verBoundAnnotName)
+                    if (TryGet(verBoundAnnotName, out var verBoundAnnot))
+                        _annots[i].VerBoundAnnot = verBoundAnnot;
+                    else
+                        throw new InvalidOperationException($"{verBoundAnnotName} added as bound anotation. However, it is not defined.");
+                #endregion
+            }
+        }
+    }
+    #endregion
+
+    #region AnnotationJSObject
+    private Dictionary<string, IAnnotation> CreateAnnotationJSObject()
+    {
+        var dict = _annots.ToDictionary(a => a.Name.ToLower(), a => a as IAnnotation);
+
+        if (Background is not null)
+        {
+            Background.Locate(_annots);
+            dict.Add(Background.Name.ToLower(), Background);
+        }            
+
+        return dict;
+    }
+
+    private readonly Lazy<Dictionary<string, IAnnotation>> _AnnotationJSObjectInitor;
+
+    public Dictionary<string, IAnnotation> AnnotationJSObject => _AnnotationJSObjectInitor.Value;
+    #endregion
+}

EnvelopeGenerator.API/Models/PsPdfKitAnnotation/Background.cs

@@ -0,0 +1,58 @@
+using System.Text.Json.Serialization;
+
+namespace EnvelopeGenerator.API.Models.PsPdfKitAnnotation;
+
+/// <summary>
+/// The Background is an annotation for the PSPDF Kit. However, it has no function.
+/// It is only the first annotation as a background for other annotations.
+/// </summary>
+public record Background : IAnnotation
+{
+    [JsonIgnore]
+    public double Margin { get; init; }
+
+    public string Name { get; } = "Background";
+
+    public double? Width { get; set; }
+
+    public double? Height { get; set; }
+
+    public double Left { get; set; }
+
+    public double Top { get; set; }
+
+    public Color? BackgroundColor { get; init; }
+
+    #region Border
+    public Color? BorderColor { get; init; }
+
+    public string? BorderStyle { get; init; }
+
+    public int? BorderWidth { get; set; }
+    #endregion
+
+    public void Locate(IEnumerable<IAnnotation> annotations)
+    {
+        // set Top
+        if (annotations.MinBy(a => a.Top)?.Top is double minTop)
+            Top = minTop;
+
+        // set Left
+        if (annotations.MinBy(a => a.Left)?.Left is double minLeft)
+            Left = minLeft;
+
+        // set Width
+        if(annotations.MaxBy(a => a.GetRight())?.GetRight() is double maxRight)
+            Width = maxRight - Left;
+
+        // set Height
+        if (annotations.MaxBy(a => a.GetBottom())?.GetBottom() is double maxBottom)
+            Height = maxBottom - Top;
+
+        // add margins
+        Top -= Margin;
+        Left -= Margin;
+        Width += Margin * 2;
+        Height += Margin * 2;
+    }
+}

EnvelopeGenerator.API/Models/PsPdfKitAnnotation/Color.cs

@@ -0,0 +1,10 @@
+namespace EnvelopeGenerator.API.Models.PsPdfKitAnnotation;
+
+public record Color
+{
+    public int R { get; init; } = 0;
+
+    public int G { get; init; } = 0;
+
+    public int B { get; init; } = 0;
+}

EnvelopeGenerator.API/Models/PsPdfKitAnnotation/Extensions.cs

@@ -0,0 +1,8 @@
+namespace EnvelopeGenerator.API.Models.PsPdfKitAnnotation;
+
+public static class Extensions
+{
+    public static double GetRight(this IAnnotation annotation) => annotation.Left + annotation?.Width ?? 0;
+
+    public static double GetBottom(this IAnnotation annotation) => annotation.Top + annotation?.Height ?? 0;
+}

EnvelopeGenerator.API/Models/PsPdfKitAnnotation/IAnnotation.cs

@@ -0,0 +1,22 @@
+namespace EnvelopeGenerator.API.Models.PsPdfKitAnnotation;
+
+public interface IAnnotation
+{
+    string Name { get; }
+
+    double? Width { get; }
+
+    double? Height { get; }
+
+    double Left { get; }
+
+    double Top { get; }
+
+    Color? BackgroundColor { get; }
+
+    Color? BorderColor { get; }
+
+    string? BorderStyle { get; }
+
+    int? BorderWidth { get; }
+}

EnvelopeGenerator.API/Models/TFARegParams.cs

@@ -0,0 +1,17 @@
+namespace EnvelopeGenerator.API.Models;
+
+/// <summary>
+/// Represents the parameters for two-factor authentication (2FA) registration.
+/// </summary>
+public class TFARegParams
+{
+    /// <summary>
+    /// The maximum allowed time for completing the registration process.
+    /// </summary>
+    public TimeSpan TimeLimit { get; init; } = new(0, 30, 0);
+
+    /// <summary>
+    /// The deadline for registration, calculated as the current time plus the <see cref="TimeLimit"/>.
+    /// </summary>
+    public DateTime Deadline => DateTime.Now.AddTicks(TimeLimit.Ticks);
+}

EnvelopeGenerator.API/Program.cs

@@ -1,6 +1,7 @@
 using DigitalData.Core.API;
 using DigitalData.Core.Application;
 using EnvelopeGenerator.Infrastructure;
+using EnvelopeGenerator.Domain.Constants;
 using Microsoft.AspNetCore.Authentication.Cookies;
 using Microsoft.AspNetCore.Localization;
 using Microsoft.EntityFrameworkCore;
@@ -11,11 +12,11 @@ using DigitalData.UserManager.DependencyInjection;
 using EnvelopeGenerator.Application;
 using DigitalData.Auth.Client;
 using DigitalData.Core.Abstractions;
-using EnvelopeGenerator.GeneratorAPI.Models;
+using EnvelopeGenerator.API.Models;
 using Microsoft.AspNetCore.Authentication.JwtBearer;
 using Microsoft.IdentityModel.Tokens;
 using DigitalData.Core.Abstractions.Security.Extensions;
-using EnvelopeGenerator.GeneratorAPI.Middleware;
+using EnvelopeGenerator.API.Middleware;
 using NLog.Web;
 using NLog;
 
@@ -26,6 +27,8 @@ try
 {
     var builder = WebApplication.CreateBuilder(args);
 
+    builder.Configuration.AddJsonFile("yarp.json", optional: true, reloadOnChange: true);
+
     builder.Logging.SetMinimumLevel(Microsoft.Extensions.Logging.LogLevel.Trace);
 
     if (!builder.Environment.IsDevelopment())
@@ -39,6 +42,8 @@ try
     var deferredProvider = new DeferredServiceProvider();
 
     builder.Services.AddControllers();
+    builder.Services.AddHttpClient();
+    builder.Services.AddReverseProxy().LoadFromConfig(builder.Configuration.GetSection("ReverseProxy"));
 
     // CORS Policy
     var allowedOrigins = config.GetSection("AllowedOrigins").Get<string[]>() ??
@@ -89,7 +94,7 @@ try
             {
                 Reference = new OpenApiReference
                 {
-                    Type = ReferenceType.SecurityScheme,
+                    Type = Microsoft.OpenApi.Models.ReferenceType.SecurityScheme,
                     Id = "Bearer"
                 }
             },
@@ -102,6 +107,8 @@ try
         {
             options.IncludeXmlComments(xmlFile);
         }
+
+        options.DocumentFilter<EnvelopeGenerator.API.Documentation.AuthProxyDocumentFilter>();
     });
     builder.Services.AddOpenApi();
 
@@ -170,6 +177,16 @@ try
         options.SlidingExpiration = true;
     });
 
+    builder.Services.AddAuthorizationBuilder()
+        .AddPolicy(AuthPolicy.SenderOrReceiver, policy =>
+            policy.RequireRole(Role.Sender, Role.Receiver.Full))
+        .AddPolicy(AuthPolicy.Sender, policy =>
+            policy.RequireRole(Role.Sender))
+        .AddPolicy(AuthPolicy.Receiver, policy =>
+            policy.RequireRole(Role.Receiver.Full))
+        .AddPolicy(AuthPolicy.ReceiverTFA, policy =>
+            policy.RequireRole(Role.Receiver.TFA));
+
     // User manager
 #pragma warning disable CS0618 // Type or member is obsolete
     builder.Services.AddUserManager<EGDbContext>();
@@ -185,7 +202,19 @@ try
     // Envelope generator serives
 #pragma warning disable CS0618 // Type or member is obsolete
     builder.Services
-        .AddEnvelopeGeneratorInfrastructureServices(sqlExecutorConfigureOptions: executor => executor.ConnectionString = connStr)
+        .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();
+            });
+            opt.AddSQLExecutor(executor => executor.ConnectionString = connStr);
+        })
         .AddEnvelopeGeneratorServices(config);
 #pragma warning restore CS0618 // Type or member is obsolete
 
@@ -229,6 +258,7 @@ try
     app.UseAuthentication();
     app.UseAuthorization();
 
+    app.MapReverseProxy();
     app.MapControllers();
 
     app.Run();

EnvelopeGenerator.API/appsettings.Development.json

@@ -6,11 +6,11 @@
     }
   },
   "AuthClientParams": {
-    "Url": "https://localhost:7192/auth-hub",
+    "Url": "http://172.24.12.39:9090/auth-hub",
     "PublicKeys": [
       {
         "Issuer": "auth.digitaldata.works",
-        "Audience": "sign-flow-gen.digitaldata.works"
+        "Audience": "sign-flow.digitaldata.works"
       }
     ],
     "RetryDelay": "00:00:05"

EnvelopeGenerator.API/appsettings.json

@@ -9,7 +9,7 @@
     }
   },
   "AllowedHosts": "*",
-  "AllowedOrigins": [ "http://localhost:4200" ],
+  "AllowedOrigins": [ "http://localhost:4200", "http://172.24.12.39:9090", "https://localhost:8088", "http://localhost:5131", "http://localhost:7192" ],
   "ConnectionStrings": {
     "Default": "Server=SDD-VMP04-SQL17\\DD_DEVELOP01;Database=DD_ECM;User Id=sa;Password=dd;Encrypt=false;TrustServerCertificate=True;",
     "DbMigrationTest": "Server=SDD-VMP04-SQL17\\DD_DEVELOP01;Database=DD_ECM_DATA_MIGR_TEST;User Id=sa;Password=dd;Encrypt=false;TrustServerCertificate=True;"
@@ -24,11 +24,11 @@
     }
   },
   "AuthClientParams": {
-    "Url": "https://localhost:7192/auth-hub",
+    "Url": "http://172.24.12.39:9090/auth-hub",
     "PublicKeys": [
       {
         "Issuer": "auth.digitaldata.works",
-        "Audience": "sign-flow-gen.digitaldata.works"
+        "Audience": "sign-flow.digitaldata.works"
       }
     ],
     "RetryDelay": "00:00:05"
@@ -37,7 +37,7 @@
     "Cookie": "AuthToken",
     "QueryString": "AuthToken",
     "Issuer": "auth.digitaldata.works",
-    "Audience": "work-flow.digitaldata.works"
+    "Audience": "sign-flow.digitaldata.works"
   },
   "PSPDFKitLicenseKey": "SXCtGGY9XA-31OGUXQK-r7c6AkdLGPm2ljuyDr1qu0kkhLvydg-Do-fxpNUF4Rq3fS_xAnZRNFRHbXpE6sQ2BMcCSVTcXVJO6tPviexjpiT-HnrDEySlUERJnnvh-tmeOWprxS6BySPnSILkmaVQtUfOIUS-cUbvvEYHTvQBKbSF8di4XHQFyfv49ihr51axm3NVV3AXwh2EiKL5C5XdqBZ4sQ4O7vXBjM2zvxdPxlxdcNYmiU83uAzw7B83O_jubPzya4CdUHh_YH7Nlp2gP56MeG1Sw2JhMtfG3Rj14Sg4ctaeL9p6AEWca5dDjJ2li5tFIV2fQSsw6A_cowLu0gtMm5i8IfJXeIcQbMC2-0wGv1oe9hZYJvFMdzhTM_FiejM0agemxt3lJyzuyP8zbBSOgp7Si6A85krLWPZptyZBTG7pp7IHboUHfPMxCXqi-zMsqewOJtQBE2mjntU-lPryKnssOpMPfswwQX7QSkJYV5EMqNmEhQX6mEkp2wcqFzMC7bJQew1aO4pOpvChUaMvb1vgRek0HxLag0nwQYX2YrYGh7F_xXJs-8HNwJe8H0-eW4x4faayCgM5rB5772CCCsD9ThZcvXFrjNHHLGJ8WuBUFm6LArvSfFQdii_7j-_sqHMpeKZt26NFgivj1A==",
   "Content-Security-Policy": [ // The first format parameter {0} will be replaced by the nonce value.

EnvelopeGenerator.API/yarp.json

@@ -0,0 +1,25 @@
+{
+  "ReverseProxy": {
+    "Routes": {
+      "auth-login": {
+        "ClusterId": "auth-hub",
+        "Match": {
+          "Path": "/api/auth",
+          "Methods": [ "POST" ]
+        },
+        "Transforms": [
+          { "PathSet": "/api/auth/sign-flow" }
+        ]
+      }
+    },
+    "Clusters": {
+      "auth-hub": {
+        "Destinations": {
+          "primary": {
+            "Address": "http://172.24.12.39:9090"
+          }
+        }
+      }
+    }
+  }
+}

EnvelopeGenerator.Application/Common/Commands/CreateCommandHandler.cs

@@ -0,0 +1,36 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using MediatR;
+
+namespace EnvelopeGenerator.Application.Common.Commands;
+
+/// <summary>
+/// 
+/// </summary>
+/// <typeparam name="TCommand"></typeparam>
+/// <typeparam name="TEntity"></typeparam>
+public class CreateCommandHandler<TCommand, TEntity> : IRequestHandler<TCommand, TEntity>
+    where TCommand : class, IRequest<TEntity>
+    where TEntity : class
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    protected readonly IRepository<TEntity> Repository;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="repository"></param>
+    public CreateCommandHandler(IRepository<TEntity> repository)
+    {
+        Repository = repository;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancel"></param>
+    /// <returns></returns>
+    public Task<TEntity> Handle(TCommand request, CancellationToken cancel) => Repository.CreateAsync(request, cancel);
+}

EnvelopeGenerator.Application/Common/Commands/UpdateCommand.cs

@@ -0,0 +1,59 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using MediatR;
+using System.Linq.Expressions;
+
+namespace EnvelopeGenerator.Application.Common.Commands;
+
+/// <summary>
+/// 
+/// </summary>
+/// <typeparam name="TUpdateDto"></typeparam>
+/// <typeparam name="TEntity"></typeparam>
+public abstract record UpdateCommand<TUpdateDto, TEntity> : IRequest where TUpdateDto : class where TEntity : class
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public TUpdateDto Update { get; init; } = null!;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <returns></returns>
+    public abstract Expression<Func<TEntity, bool>> BuildQueryExpression();
+}
+
+/// <summary>
+/// 
+/// </summary>
+/// <typeparam name="TCommand"></typeparam>
+/// <typeparam name="TUpdateDto"></typeparam>
+/// <typeparam name="TEntity"></typeparam>
+public class UpdateCommandHandler<TCommand, TUpdateDto, TEntity> : IRequestHandler<TCommand>
+    where TUpdateDto : class
+    where TEntity : class
+    where TCommand : UpdateCommand<TUpdateDto, TEntity>
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    protected readonly IRepository<TEntity> Repository;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="repository"></param>
+    public UpdateCommandHandler(IRepository<TEntity> repository)
+    {
+        Repository = repository;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancel"></param>
+    /// <returns></returns>
+    public Task Handle(TCommand request, CancellationToken cancel)
+        => Repository.UpdateAsync(request.Update, request.BuildQueryExpression(), cancel);
+}

EnvelopeGenerator.Application/Common/Configurations/DbTriggerParams.cs

@@ -1,8 +0,0 @@
-namespace EnvelopeGenerator.Application.Common.Configurations;
-
-/// <summary>
-/// 
-/// </summary>
-public class DbTriggerParams : Dictionary<string, ICollection<string>>
-{
-}

EnvelopeGenerator.Application/Common/Dto/AnnotationDto.cs

@@ -0,0 +1,73 @@
+namespace EnvelopeGenerator.Application.Common.Dto;
+
+/// <summary>
+/// 
+/// </summary>
+public record AnnotationCreateDto
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public int ElementId { get; init; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public string Name { get; init; } = null!;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public string Value { get; init; } = null!;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public string Type { get; init; } = null!;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public double? X { get; init; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public double? Y { get; init; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public double? Width { get; init; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public double? Height { get; init; }
+}
+
+/// <summary>
+/// 
+/// </summary>
+public record AnnotationDto : AnnotationCreateDto
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public long Id { get; init; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public DateTime AddedWhen { get; init; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public DateTime? ChangedWhen { get; init; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public string? ChangedWho { get; init; }
+}

EnvelopeGenerator.Application/Common/Dto/EmailTemplateDto.cs

@@ -1,31 +1,37 @@
-using Microsoft.AspNetCore.Mvc;
+namespace EnvelopeGenerator.Application.Common.Dto;
 
-namespace EnvelopeGenerator.Application.Common.Dto
+/// <summary>
+/// 
+/// </summary>
+public record EmailTemplateDto
 {
     /// <summary>
     /// 
     /// </summary>
-    [ApiExplorerSettings(IgnoreApi = true)]
-    public record EmailTemplateDto
-    {
-        /// <summary>
-        /// 
-        /// </summary>
-        public int Id{ get; init; }
+    public int Id { get; init; }
 
-        /// <summary>
-        /// 
-        /// </summary>
-        public required string Name { get; init; }
+    /// <summary>
+    /// 
+    /// </summary>
+    public required string Name { get; init; }
 
-        /// <summary>
-        /// 
-        /// </summary>
-        public required string Body { get; set; }
+    /// <summary>
+    /// Das Datum und die Uhrzeit, wann die Vorlage hinzugefügt wurde.
+    /// </summary>
+    public DateTime AddedWhen { get; init; }
 
-        /// <summary>
-        /// 
-        /// </summary>
-        public required string Subject { get; set; }
-    };
-}
+    /// <summary>
+    /// Der Inhalt (Body) der E-Mail-Vorlage. Kann null sein.
+    /// </summary>
+    public string? Body { get; init; }
+
+    /// <summary>
+    /// Der Betreff der E-Mail-Vorlage. Kann null sein.
+    /// </summary>
+    public string? Subject { get; init; }
+
+    /// <summary>
+    /// Das Datum und die Uhrzeit, wann die Vorlage zuletzt geändert wurde. Kann null sein.
+    /// </summary>
+    public DateTime? ChangedWhen { get; init; }
+};

EnvelopeGenerator.Application/Common/Dto/EnvelopeDto.cs

@@ -74,6 +74,11 @@ public record EnvelopeDto
     /// </summary>
     public int? EnvelopeTypeId { get; set; }
 
+    /// <summary>
+    /// 
+    /// </summary>
+    public bool ReadOnly => EnvelopeTypeId == 2;
+
     /// <summary>
     /// 
     /// </summary>
@@ -82,7 +87,7 @@ public record EnvelopeDto
     /// <summary>
     /// 
     /// </summary>
-    public bool? UseAccessCode { get; set; }
+    public bool UseAccessCode { get; set; } = true;
 
     /// <summary>
     /// 

EnvelopeGenerator.Application/Common/Dto/MappingProfile.cs

@@ -28,13 +28,14 @@ public class MappingProfile : Profile
         CreateMap<EmailTemplate, EmailTemplateDto>();
         CreateMap<Envelope, EnvelopeDto>();
         CreateMap<Document, DocumentDto>();
-        CreateMap<Domain.Entities.History, HistoryDto>();
-        CreateMap<Domain.Entities.History, HistoryCreateDto>();
+        CreateMap<Domain.Entities.History, HistoryDto>().ForMember(dest => dest.ActionDate, opt => opt.MapFrom(src => src.ChangedWhen));
+        CreateMap<Domain.Entities.History, HistoryCreateDto>().ForMember(dest => dest.ActionDate, opt => opt.MapFrom(src => src.ChangedWhen));
         CreateMap<Domain.Entities.EnvelopeReceiver, EnvelopeReceiverDto>();
         CreateMap<Domain.Entities.EnvelopeReceiver, EnvelopeReceiverSecretDto>();
         CreateMap<EnvelopeType, EnvelopeTypeDto>();
         CreateMap<Domain.Entities.Receiver, ReceiverDto>();
         CreateMap<Domain.Entities.EnvelopeReceiverReadOnly, EnvelopeReceiverReadOnlyDto>();
+        CreateMap<ElementAnnotation, AnnotationDto>();
 
         // DTO to Entity mappings
         CreateMap<ConfigDto, Config>();
@@ -43,13 +44,15 @@ public class MappingProfile : Profile
         CreateMap<EmailTemplateDto, EmailTemplate>();
         CreateMap<EnvelopeDto, Envelope>();
         CreateMap<DocumentDto, Document>();
-        CreateMap<HistoryDto, Domain.Entities.History>();
-        CreateMap<HistoryCreateDto, Domain.Entities.History>();
+        CreateMap<HistoryDto, Domain.Entities.History>().ForMember(dest => dest.ChangedWhen, opt => opt.MapFrom(src => src.ActionDate));
+        CreateMap<HistoryCreateDto, Domain.Entities.History>().ForMember(dest => dest.ChangedWhen, opt => opt.MapFrom(src => src.ActionDate));
         CreateMap<EnvelopeReceiverDto, Domain.Entities.EnvelopeReceiver>();
         CreateMap<EnvelopeTypeDto, EnvelopeType>();
         CreateMap<ReceiverDto, Domain.Entities.Receiver>().ForMember(rcv => rcv.EnvelopeReceivers, rcvReadDto => rcvReadDto.Ignore());
         CreateMap<EnvelopeReceiverReadOnlyCreateDto, Domain.Entities.EnvelopeReceiverReadOnly>();
         CreateMap<EnvelopeReceiverReadOnlyUpdateDto, Domain.Entities.EnvelopeReceiverReadOnly>();
+        CreateMap<AnnotationCreateDto, ElementAnnotation>()
+            .MapAddedWhen();
 
         // Messaging mappings
         // for GTX messaging

EnvelopeGenerator.Application/Common/Dto/SignatureDto.cs

@@ -1,4 +1,5 @@
-using Microsoft.AspNetCore.Mvc;
+using EnvelopeGenerator.Domain.Interfaces;
+using Microsoft.AspNetCore.Mvc;
 
 namespace EnvelopeGenerator.Application.Common.Dto;
 
@@ -6,7 +7,7 @@ namespace EnvelopeGenerator.Application.Common.Dto;
 /// Data Transfer Object representing a positioned element assigned to a document receiver.
 /// </summary>
 [ApiExplorerSettings(IgnoreApi = true)]
-public class SignatureDto
+public class SignatureDto : ISignature
 {
     /// <summary>
     /// Gets or sets the unique identifier of the element.

EnvelopeGenerator.Application/Common/Extensions/AutoMapperAuditingExtensions.cs

@@ -0,0 +1,24 @@
+using AutoMapper;
+using EnvelopeGenerator.Domain.Interfaces.Auditing;
+
+namespace EnvelopeGenerator.Application.Common.Extensions;
+
+/// <summary>
+/// Extension methods for applying auditing timestamps during AutoMapper mappings.
+/// </summary>
+public static class AutoMapperAuditingExtensions
+{
+    /// <summary>
+    /// Maps <see cref="IHasAddedWhen.AddedWhen"/> to the current UTC time.
+    /// </summary>
+    public static IMappingExpression<TSource, TDestination> MapAddedWhen<TSource, TDestination>(this IMappingExpression<TSource, TDestination> expression)
+        where TDestination : IHasAddedWhen
+        => expression.ForMember(dest => dest.AddedWhen, opt => opt.MapFrom(_ => DateTime.UtcNow));
+
+    /// <summary>
+    /// Maps <see cref="IHasChangedWhen.ChangedWhen"/> to the current UTC time.
+    /// </summary>
+    public static IMappingExpression<TSource, TDestination> MapChangedWhen<TSource, TDestination>(this IMappingExpression<TSource, TDestination> expression)
+        where TDestination : IHasChangedWhen
+        => expression.ForMember(dest => dest.ChangedWhen, opt => opt.MapFrom(_ => DateTime.UtcNow));
+}

EnvelopeGenerator.Application/Common/Extensions/LoggerExtensions.cs

@@ -3,8 +3,19 @@ using System.Text;
 
 namespace EnvelopeGenerator.Application.Common.Extensions
 {
+    /// <summary>
+    /// 
+    /// </summary>
     public static class LoggerExtensions
     {
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="logger"></param>
+        /// <param name="envelopeReceiverId"></param>
+        /// <param name="exception"></param>
+        /// <param name="message"></param>
+        /// <param name="args"></param>
         public static void LogEnvelopeError(this ILogger logger, string envelopeReceiverId, Exception? exception = null, string? message = null, params object?[] args)
         {
             var sb = new StringBuilder().AppendLine(envelopeReceiverId.DecodeEnvelopeReceiverId().ToTitle());
@@ -18,6 +29,15 @@ namespace EnvelopeGenerator.Application.Common.Extensions
                 logger.Log(LogLevel.Error, exception, sb.AppendLine(exception.Message).ToString(), args);
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="logger"></param>
+        /// <param name="uuid"></param>
+        /// <param name="signature"></param>
+        /// <param name="exception"></param>
+        /// <param name="message"></param>
+        /// <param name="args"></param>
         public static void LogEnvelopeError(this ILogger logger, string? uuid, string? signature = null, Exception? exception = null, string? message = null, params object?[] args)
         {
             var sb = new StringBuilder($"Envelope Uuid: {uuid}");
@@ -34,6 +54,11 @@ namespace EnvelopeGenerator.Application.Common.Extensions
                 logger.Log(LogLevel.Error, exception, sb.ToString(), args);
         }
 
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="envelopeReceiverTuple"></param>
+        /// <returns></returns>
         public static string ToTitle(this (string? UUID, string? Signature) envelopeReceiverTuple)
         {
             return $"UUID is {envelopeReceiverTuple.UUID} and signature is {envelopeReceiverTuple.Signature}";

EnvelopeGenerator.Application/Common/Extensions/TaskExtensions.cs

@@ -5,6 +5,7 @@ namespace EnvelopeGenerator.Application.Common.Extensions;
 /// <summary>
 /// Extension methods for tasks
 /// </summary>
+[Obsolete("Implement Mediator behaviors in the Osolete .NET project.")]
 public static class TaskExtensions
 {
     /// <summary>
@@ -17,6 +18,7 @@ public static class TaskExtensions
     /// <param name="factory">Exception provider</param>
     /// <returns>The awaited result if not <c>null</c>.</returns>
     /// <exception>Thrown if the result is <c>null</c>.</exception>
+    [Obsolete("Implement Mediator behaviors in the Osolete .NET project.")]
     public static async Task<T> ThrowIfNull<T, TException>(this Task<T?> task, Func<TException> factory) where TException : Exception
     {
         var result = await task;
@@ -33,6 +35,7 @@ public static class TaskExtensions
     /// <param name="factory">Exception provider</param>
     /// <returns>The awaited collection if it is not <c>null</c> or empty.</returns>
     /// <exception cref="NotFoundException">Thrown if the result is <c>null</c> or empty.</exception>
+    [Obsolete("Implement Mediator behaviors in the Osolete .NET project.")]
     public static async Task<IEnumerable<T>> ThrowIfEmpty<T, TException>(this Task<IEnumerable<T>> task, Func<TException> factory) where TException : Exception
     {
         var result = await task;
@@ -47,11 +50,33 @@ public static class TaskExtensions
     /// <param name="task"></param>
     /// <param name="act"></param>
     /// <returns></returns>
+    [Obsolete("Implement Mediator behaviors in the Osolete .NET project.")]
     public static async Task<I> Then<T, I>(this Task<T> task, Func<T, I> act)
     {
         var res = await task;
         return act(res);
     }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    /// <param name="task"></param>
+    /// <returns></returns>
+    [Obsolete("Implement Mediator behaviors in the Osolete .NET project.")]
+    public static Task<T?> FirstOrDefaultAsync<T>(this Task<IEnumerable<T>> task) => task.Then(t => t.FirstOrDefault());
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    /// <typeparam name="TException"></typeparam>
+    /// <param name="task"></param>
+    /// <param name="factory"></param>
+    /// <returns></returns>
+    public static Task<T> FirstAsync<T, TException>(this Task<IEnumerable<T>> task, Func<TException> factory) 
+        where TException : Exception 
+        => task.Then(t => t.FirstOrDefault() ?? throw factory());
 }
 
 /// <summary>
@@ -68,11 +93,13 @@ public static class Exceptions
     /// 
     /// </summary>
     /// <returns></returns>
+    [Obsolete("Implement Mediator behaviors in the Osolete .NET project.")]
     public static BadRequestException BadRequest() => new();
 
     /// <summary>
     /// 
     /// </summary>
     /// <returns></returns>
+    [Obsolete("Implement Mediator behaviors in the Osolete .NET project.")]
     public static ForbiddenException Forbidden() => new();
 }

EnvelopeGenerator.Application/Common/Extensions/XSSExtensions.cs

@@ -2,16 +2,42 @@
 using Microsoft.Extensions.Localization;
 using System.Text.Encodings.Web;
 
-namespace EnvelopeGenerator.Application.Common.Extensions
+namespace EnvelopeGenerator.Application.Common.Extensions;
+
+/// <summary>
+/// 
+/// </summary>
+public static class XSSExtensions
 {
-    public static class XSSExtensions
-    {
-        public static string? TryEncode(this string? value, UrlEncoder encoder) => value is null ? value : encoder.Encode(value);
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="value"></param>
+    /// <param name="encoder"></param>
+    /// <returns></returns>
+    public static string? TryEncode(this string? value, UrlEncoder encoder) => value is null ? value : encoder.Encode(value);
 
-        public static string? TryEncode(this LocalizedString? value, UrlEncoder encoder) => value is null ? null : encoder.Encode(value);
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="value"></param>
+    /// <param name="encoder"></param>
+    /// <returns></returns>
+    public static string? TryEncode(this LocalizedString? value, UrlEncoder encoder) => value is null ? null : encoder.Encode(value);
 
-        public static string? TrySanitize(this string? html, HtmlSanitizer sanitizer) => html is null ? html : sanitizer.Sanitize(html);
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="html"></param>
+    /// <param name="sanitizer"></param>
+    /// <returns></returns>
+    public static string? TrySanitize(this string? html, HtmlSanitizer sanitizer) => html is null ? html : sanitizer.Sanitize(html);
 
-        public static string? TrySanitize(this LocalizedString? html, HtmlSanitizer sanitizer) => html is null ? null : sanitizer.Sanitize(html);
-    }
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="html"></param>
+    /// <param name="sanitizer"></param>
+    /// <returns></returns>
+    public static string? TrySanitize(this LocalizedString? html, HtmlSanitizer sanitizer) => html is null ? null : sanitizer.Sanitize(html);
 }

EnvelopeGenerator.Application/Common/Notifications/DocSigned/DocSignedNotification.cs

@@ -1,12 +1,20 @@
-using EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiver;
+using EnvelopeGenerator.Application.Common.Dto;
+using EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiver;
 using EnvelopeGenerator.Application.Common.Extensions;
+using EnvelopeGenerator.Application.Common.Notifications.RemoveSignature;
 using EnvelopeGenerator.Domain.Constants;
 using MediatR;
-using Newtonsoft.Json;
 using System.Dynamic;
 
 namespace EnvelopeGenerator.Application.Common.Notifications.DocSigned;
 
+/// <summary>
+/// 
+/// </summary>
+/// <param name="Instant"></param>
+/// <param name="Structured"></param>
+public record PsPdfKitAnnotation(ExpandoObject Instant, IEnumerable<AnnotationCreateDto> Structured);
+
 /// <summary>
 /// 
 /// </summary>
@@ -16,7 +24,7 @@ public record DocSignedNotification(EnvelopeReceiverDto Original) : EnvelopeRece
     /// <summary>
     /// 
     /// </summary>
-    public required ExpandoObject Annotations { get; init; }
+    public PsPdfKitAnnotation? PsPdfKitAnnotation { get; init; }
 
     /// <summary>
     /// 
@@ -40,17 +48,41 @@ public static class DocSignedNotificationExtensions
     /// Converts an <see cref="EnvelopeReceiverDto"/> to a <see cref="DocSignedNotification"/>.
     /// </summary>
     /// <param name="dto">The DTO to convert.</param>
-    /// <param name="annotations"></param>
+    /// <param name="psPdfKitAnnotation"></param>
     /// <returns>A new <see cref="DocSignedNotification"/> instance.</returns>
-    public static DocSignedNotification ToDocSignedNotification(this EnvelopeReceiverDto dto, ExpandoObject annotations)
-        => new(dto) { Annotations = annotations };
+    public static DocSignedNotification ToDocSignedNotification(this EnvelopeReceiverDto dto, PsPdfKitAnnotation psPdfKitAnnotation)
+        => new(dto) { PsPdfKitAnnotation = psPdfKitAnnotation };
 
     /// <summary>
-    /// Asynchronously converts a <see cref="Task{EnvelopeReceiverDto}"/> to a <see cref="DocSignedNotification"/>.
+    /// 
     /// </summary>
-    /// <param name="dtoTask">The task that returns the DTO to convert.</param>
-    /// <param name="annotations"></param>
-    /// <returns>A task that represents the asynchronous conversion operation.</returns>
-    public static async Task<DocSignedNotification?> ToDocSignedNotification(this Task<EnvelopeReceiverDto?> dtoTask, ExpandoObject annotations)
-        => await dtoTask is EnvelopeReceiverDto dto ? new(dto) { Annotations = annotations } : null;
+    /// <param name="dtoTask"></param>
+    /// <param name="psPdfKitAnnotation"></param>
+    /// <returns></returns>
+    public static async Task<DocSignedNotification?> ToDocSignedNotification(this Task<EnvelopeReceiverDto?> dtoTask, PsPdfKitAnnotation? psPdfKitAnnotation)
+        => await dtoTask is EnvelopeReceiverDto dto ? new(dto) { PsPdfKitAnnotation = psPdfKitAnnotation } : null;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="publisher"></param>
+    /// <param name="notification"></param>
+    /// <param name="cancel"></param>
+    /// <returns></returns>
+    public static async Task PublishSafely(this IPublisher publisher, DocSignedNotification notification, CancellationToken cancel = default)
+    {
+        try
+        {
+            await publisher.Publish(notification, cancel);
+        }
+        catch (Exception)
+        {
+            await publisher.Publish(new RemoveSignatureNotification()
+            {
+                EnvelopeId = notification.EnvelopeId,
+                ReceiverId = notification.ReceiverId
+            }, cancel);
+            throw;
+        }
+    }
 }

EnvelopeGenerator.Application/Common/Notifications/DocSigned/Handlers/AnnotationHandler.cs

@@ -1,7 +1,6 @@
-using EnvelopeGenerator.Application.DocStatus.Commands;
-using EnvelopeGenerator.Domain.Constants;
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Domain.Entities;
 using MediatR;
-using System.Text.Json;
 
 namespace EnvelopeGenerator.Application.Common.Notifications.DocSigned.Handlers;
 
@@ -10,15 +9,18 @@ namespace EnvelopeGenerator.Application.Common.Notifications.DocSigned.Handlers;
 /// </summary>
 public class AnnotationHandler : INotificationHandler<DocSignedNotification>
 {
-    private readonly ISender _sender;
+    /// <summary>
+    /// 
+    /// </summary>
+    private readonly IRepository<ElementAnnotation> _repo;
 
     /// <summary>
     /// 
     /// </summary>
-    /// <param name="sender"></param>
-    public AnnotationHandler(ISender sender)
+    /// <param name="repository"></param>
+    public AnnotationHandler(IRepository<ElementAnnotation> repository)
     {
-        _sender = sender;
+        _repo = repository;
     }
 
     /// <summary>
@@ -29,11 +31,7 @@ public class AnnotationHandler : INotificationHandler<DocSignedNotification>
     /// <returns></returns>
     public async Task Handle(DocSignedNotification notification, CancellationToken cancel)
     {
-        await _sender.Send(new SaveDocStatusCommand()
-        {
-            Envelope = new() { Id = notification.EnvelopeId },
-            Receiver = new() { Id = notification.ReceiverId},
-            Value = JsonSerializer.Serialize(notification.Annotations, Format.Json.ForAnnotations)
-        }, cancel);
+        if (notification.PsPdfKitAnnotation is PsPdfKitAnnotation annot)
+            await _repo.CreateAsync(annot.Structured, cancel);
     }
 }

EnvelopeGenerator.Application/Common/Notifications/DocSigned/Handlers/DocStatusHandler.cs

@@ -0,0 +1,43 @@
+using EnvelopeGenerator.Application.DocStatus.Commands;
+using EnvelopeGenerator.Domain.Constants;
+using MediatR;
+using System.Text.Json;
+
+namespace EnvelopeGenerator.Application.Common.Notifications.DocSigned.Handlers;
+
+/// <summary>
+/// 
+/// </summary>
+public class DocStatusHandler : INotificationHandler<DocSignedNotification>
+{
+    private const string BlankAnnotationJson = "{}";
+
+    private readonly ISender _sender;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="sender"></param>
+    public DocStatusHandler(ISender sender)
+    {
+        _sender = sender;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="notification"></param>
+    /// <param name="cancel"></param>
+    /// <returns></returns>
+    public async Task Handle(DocSignedNotification notification, CancellationToken cancel)
+    {
+        await _sender.Send(new SaveDocStatusCommand()
+        {
+            Envelope = new() { Id = notification.EnvelopeId },
+            Receiver = new() { Id = notification.ReceiverId},
+            Value = notification.PsPdfKitAnnotation is PsPdfKitAnnotation annot 
+                    ? JsonSerializer.Serialize(annot.Instant, Format.Json.ForAnnotations) 
+                    : BlankAnnotationJson
+        }, cancel);
+    }
+}

EnvelopeGenerator.Application/Common/Notifications/DocSigned/Handlers/HistoryHandler.cs

@@ -2,7 +2,6 @@
 using EnvelopeGenerator.Application.Histories.Commands;
 using EnvelopeGenerator.Domain.Constants;
 using MediatR;
-using Newtonsoft.Json;
 
 namespace EnvelopeGenerator.Application.Common.Notifications.DocSigned.Handlers;
 

EnvelopeGenerator.Application/Common/Notifications/RemoveSignature/Handlers/RemoveAnnotationHandler.cs

@@ -0,0 +1,53 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Domain.Entities;
+using MediatR;
+
+namespace EnvelopeGenerator.Application.Common.Notifications.RemoveSignature.Handlers;
+
+/// <summary>
+/// 
+/// </summary>
+public class RemoveAnnotationHandler : INotificationHandler<RemoveSignatureNotification>
+{
+    private readonly IRepository<ElementAnnotation> _repo;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="repository"></param>
+    public RemoveAnnotationHandler(IRepository<ElementAnnotation> repository)
+    {
+        _repo = repository;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="notification"></param>
+    /// <param name="cancel"></param>
+    /// <returns></returns>
+    public Task Handle(RemoveSignatureNotification notification, CancellationToken cancel)
+    {
+        notification.ThrowIfHasNoFilter();
+        return _repo.DeleteAsync(annots =>
+        {
+            // envelope ID filter
+            if (notification.EnvelopeId is int envelopeId)
+                annots = annots.Where(annot => annot.Element!.Document.EnvelopeId == envelopeId);
+
+            // envelope UUID filter
+            if (notification.EnvelopeUuid is string envelopeUuid)
+                annots = annots.Where(annot => annot.Element!.Document.Envelope!.Uuid == envelopeUuid);
+
+            // receiver ID
+            if (notification.ReceiverId is int receiverId)
+                annots = annots.Where(annot => annot.Element!.ReceiverId == receiverId);
+
+            // receiver signature
+            if (notification.ReceiverSignature is string receiverSignature)
+                annots = annots.Where(annot => annot.Element!.Receiver!.Signature == receiverSignature);
+
+            return annots;
+        }, cancel);
+    }
+}

EnvelopeGenerator.Application/Common/Notifications/RemoveSignature/Handlers/RemoveDocStatusHandler.cs

@@ -0,0 +1,53 @@
+using AngleSharp.Html;
+using DigitalData.Core.Abstraction.Application.Repository;
+using MediatR;
+
+namespace EnvelopeGenerator.Application.Common.Notifications.RemoveSignature.Handlers;
+
+/// <summary>
+/// 
+/// </summary>
+public class RemoveDocStatusHandler : INotificationHandler<RemoveSignatureNotification>
+{
+    private readonly IRepository<Domain.Entities.DocumentStatus> _repo;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="repository"></param>
+    public RemoveDocStatusHandler(IRepository<Domain.Entities.DocumentStatus> repository)
+    {
+        _repo = repository;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="notification"></param>
+    /// <param name="cancel"></param>
+    /// <returns></returns>
+    public Task Handle(RemoveSignatureNotification notification, CancellationToken cancel)
+    {
+        notification.ThrowIfHasNoFilter();
+        return _repo.DeleteAsync(statuses =>
+        {
+            // envelope ID filter
+            if (notification.EnvelopeId is int envelopeId)
+                statuses = statuses.Where(status => status.EnvelopeId == envelopeId);
+
+            // envelope UUID filter
+            if (notification.EnvelopeUuid is string envelopeUuid)
+                statuses = statuses.Where(status => status.Envelope!.Uuid == envelopeUuid);
+
+            // receiver Id filter
+            if (notification.ReceiverId is int receiverId)
+                statuses = statuses.Where(status => status.ReceiverId == receiverId);
+
+            // receiver signature filter
+            if (notification.ReceiverSignature is string receiverSignature)
+                statuses = statuses.Where(status => status.Receiver!.Signature == receiverSignature);
+
+            return statuses;
+        }, cancel);
+    }
+}

EnvelopeGenerator.Application/Common/Notifications/RemoveSignature/Handlers/RemoveHistoryHandler.cs

@@ -0,0 +1,56 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Application.Common.Extensions;
+using EnvelopeGenerator.Domain.Constants;
+using MediatR;
+
+namespace EnvelopeGenerator.Application.Common.Notifications.RemoveSignature.Handlers;
+
+/// <summary>
+/// 
+/// </summary>
+public class RemoveHistoryHandler : INotificationHandler<RemoveSignatureNotification>
+{
+    private readonly IRepository<Domain.Entities.History> _repo;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="repository"></param>
+    public RemoveHistoryHandler(IRepository<Domain.Entities.History> repository)
+    {
+        _repo = repository;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="notification"></param>
+    /// <param name="cancel"></param>
+    /// <returns></returns>
+    public Task Handle(RemoveSignatureNotification notification, CancellationToken cancel)
+    {
+        notification.ThrowIfHasNoFilter();
+        return _repo.DeleteAsync(hists =>
+        {
+            hists = hists.Where(hist => hist.Status == EnvelopeStatus.DocumentSigned);
+
+            // envelope ID filter
+            if (notification.EnvelopeId is int envelopeId)
+                hists = hists.Where(hist => hist.EnvelopeId == envelopeId);
+
+            // envelope UUID filter
+            if (notification.EnvelopeUuid is string envelopeUuid)
+                hists = hists.Where(hist => hist.Envelope!.Uuid == envelopeUuid);
+
+            // receiver ID filter
+            if (notification.ReceiverId is int receiverId)
+                hists = hists.Where(hist => hist.Receiver!.Id == receiverId);
+
+            // receiver signature filter
+            if (notification.ReceiverSignature is string receiverSignature)
+                hists = hists.Where(hist => hist.Receiver!.Signature == receiverSignature);
+
+            return hists;
+        }, cancel);
+    }
+}

EnvelopeGenerator.Application/Common/Notifications/RemoveSignature/RemoveSignatureNotification.cs

@@ -0,0 +1,37 @@
+using MediatR;
+
+namespace EnvelopeGenerator.Application.Common.Notifications.RemoveSignature;
+
+/// <summary>
+/// 
+/// </summary>
+/// <param name="EnvelopeId"></param>
+/// <param name="ReceiverId"></param>
+/// <param name="EnvelopeUuid"></param>
+/// <param name="ReceiverSignature"></param>
+public record RemoveSignatureNotification(
+    int? EnvelopeId = null,
+    int? ReceiverId = null,
+    string? EnvelopeUuid = null,
+    string? ReceiverSignature = null
+    ) : INotification
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public bool HasFilter => 
+        EnvelopeId is not null 
+        || ReceiverId is not null 
+        || EnvelopeUuid is not null 
+        || ReceiverSignature is not null;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <exception cref="InvalidOperationException"></exception>
+    public void ThrowIfHasNoFilter()
+    {
+        if (!HasFilter)
+            throw new InvalidOperationException("At least one filter parameter must be provided.");
+    }
+}

EnvelopeGenerator.Application/DependencyInjection.cs

@@ -46,7 +46,6 @@ public static class DependencyInjection
         services.Configure<MailParams>(config.GetSection(nameof(MailParams)));
         services.Configure<AuthenticatorParams>(config.GetSection(nameof(AuthenticatorParams)));
         services.Configure<TotpSmsParams>(config.GetSection(nameof(TotpSmsParams)));
-        services.Configure<DbTriggerParams>(config.GetSection(nameof(DbTriggerParams)));
 
         services.AddHttpClientService<GtxMessagingParams>(config.GetSection(nameof(GtxMessagingParams)));
         services.TryAddSingleton<ISmsSender, GTXSmsSender>();

EnvelopeGenerator.Application/DocStatus/Commands/CreateDocStatusCommand.cs

@@ -1,12 +1,31 @@
-namespace EnvelopeGenerator.Application.DocStatus.Commands;
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Application.Common.Commands;
+using EnvelopeGenerator.Domain.Entities;
+using MediatR;
+
+namespace EnvelopeGenerator.Application.DocStatus.Commands;
 
 /// <summary>
 /// 
 /// </summary>
-public record CreateDocStatusCommand : ModifyDocStatusCommandBase
+public record CreateDocStatusCommand : ModifyDocStatusCommandBase, IRequest<DocumentStatus>
 {
     /// <summary>
     /// Gets timestamp when this record was added. Returns the StatusChangedWhen value.
     /// </summary>
     public DateTime AddedWhen => StatusChangedWhen;
+}
+
+/// <summary>
+/// 
+/// </summary>
+public class CreateDocStatusCommandHandler : CreateCommandHandler<CreateDocStatusCommand, DocumentStatus>
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="repository"></param>
+    public CreateDocStatusCommandHandler(IRepository<DocumentStatus> repository) : base(repository)
+    {
+    }
 }

EnvelopeGenerator.Application/DocStatus/MappingProfile.cs

@@ -1,4 +1,5 @@
 using AutoMapper;
+using EnvelopeGenerator.Application.Common.Extensions;
 using EnvelopeGenerator.Application.DocStatus.Commands;
 using EnvelopeGenerator.Domain.Entities;
 
@@ -16,10 +17,12 @@ public class MappingProfile : Profile
     {
         CreateMap<CreateDocStatusCommand, DocumentStatus>()
         .ForMember(dest => dest.Envelope, opt => opt.Ignore())
-        .ForMember(dest => dest.Receiver, opt => opt.Ignore());
+        .ForMember(dest => dest.Receiver, opt => opt.Ignore())
+        .MapAddedWhen();
 
         CreateMap<UpdateDocStatusCommand, DocumentStatus>()
         .ForMember(dest => dest.Envelope, opt => opt.Ignore())
-        .ForMember(dest => dest.Receiver, opt => opt.Ignore());
+        .ForMember(dest => dest.Receiver, opt => opt.Ignore())
+        .MapChangedWhen();
     }
 }

EnvelopeGenerator.Application/Documents/Queries/ReadDocumentQuery.cs

@@ -4,6 +4,7 @@ using EnvelopeGenerator.Domain.Entities;
 using Microsoft.EntityFrameworkCore;
 using AutoMapper;
 using EnvelopeGenerator.Application.Common.Dto;
+using DigitalData.Core.Exceptions;
 
 namespace EnvelopeGenerator.Application.Documents.Queries;
 
@@ -12,14 +13,14 @@ namespace EnvelopeGenerator.Application.Documents.Queries;
 /// </summary>
 /// <param name="Id">The unique identifier of the document. Optional.</param>
 /// <param name="EnvelopeId">The identifier of the envelope associated with the document. Optional.</param>
-public record ReadDocumentQuery(int? Id = null, int? EnvelopeId = null) : IRequest<DocumentDto?>
+public record ReadDocumentQuery(int? Id = null, int? EnvelopeId = null) : IRequest<DocumentDto>
 {
 }
 
 /// <summary>
 /// Handles queries for reading <see cref="Document"/> data based on either the document ID or the envelope ID.
 /// </summary>
-public class ReadDocumentQueryHandler : IRequestHandler<ReadDocumentQuery, DocumentDto?>
+public class ReadDocumentQueryHandler : IRequestHandler<ReadDocumentQuery, DocumentDto>
 {
     /// <summary>
     /// TempRepo for accessing <see cref="Document"/> entities.
@@ -50,20 +51,19 @@ public class ReadDocumentQueryHandler : IRequestHandler<ReadDocumentQuery, Docum
     /// <exception cref="InvalidOperationException">
     /// Thrown when neither <see cref="ReadDocumentQuery.Id"/> nor <see cref="ReadDocumentQuery.EnvelopeId"/> is provided.
     /// </exception>
-    public async Task<DocumentDto?> Handle(ReadDocumentQuery query, CancellationToken cancel)
+    public async Task<DocumentDto> Handle(ReadDocumentQuery query, CancellationToken cancel)
     {
         if (query.Id is not null)
         {
-            var doc = await _repo.ReadOnly().Where(d => d.Id == query.Id).FirstOrDefaultAsync(cancel);
+            var doc = await _repo.Query.Where(d => d.Id == query.Id).FirstOrDefaultAsync(cancel);
             return _mapper.Map<DocumentDto>(doc);
         }            
         else if (query.EnvelopeId is not null)
         {
-            var doc = await _repo.ReadOnly().Where(d => d.EnvelopeId == query.EnvelopeId).FirstOrDefaultAsync(cancel);
+            var doc = await _repo.Query.Where(d => d.EnvelopeId == query.EnvelopeId).FirstOrDefaultAsync(cancel);
             return _mapper.Map<DocumentDto>(doc);
         }
 
-        throw new InvalidOperationException(
-            $"Invalid {nameof(ReadDocumentQuery)}: either {nameof(query.Id)} or {nameof(query.EnvelopeId)} must be provided.");
+        throw new NotFoundException();
     }
 }

EnvelopeGenerator.Application/EmailTemplates/Commands/Reset/ResetEmailTemplateCommand.cs

@@ -1,41 +0,0 @@
-using EnvelopeGenerator.Domain;
-using EnvelopeGenerator.Domain.Constants;
-using MediatR;
-
-namespace EnvelopeGenerator.Application.EmailTemplates.Commands.Reset;
-
-/// <summary>
-/// Ein Befehl zum Zurücksetzen einer E-Mail-Vorlage auf die Standardwerte.
-/// Erbt von <see cref="EmailTemplateQuery"/> und ermöglicht die Angabe einer optionalen ID und eines Typs der E-Mail-Vorlage.<br/><br/>
-/// Beispiele:<br/>
-/// 0 - DocumentReceived: Benachrichtigung über den Empfang eines Dokuments.<br/>
-/// 1 - DocumentSigned: Benachrichtigung über die Unterzeichnung eines Dokuments.<br/>
-/// 2 - DocumentDeleted: Benachrichtigung über das Löschen eines Dokuments.<br/>
-/// 3 - DocumentCompleted: Benachrichtigung über den Abschluss eines Dokuments.<br/>
-/// 4 - DocumentAccessCodeReceived: Benachrichtigung über den Erhalt eines Zugangscodes.<br/>
-/// 5 - DocumentShared: Benachrichtigung über das Teilen eines Dokuments.<br/>
-/// 6 - TotpSecret: Benachrichtigung über ein TOTP-Geheimnis.<br/>
-/// 7 - DocumentRejected_ADM (Für den Absender): Mail an den Absender, wenn das Dokument abgelehnt wird.<br/>
-/// 8 - DocumentRejected_REC (Für den ablehnenden Empfänger): Mail an den ablehnenden Empfänger, wenn das Dokument abgelehnt wird.<br/>
-/// 9 - DocumentRejected_REC_2 (Für sonstige Empfänger): Mail an andere Empfänger (Brief), wenn das Dokument abgelehnt wird.<br/>
-/// </summary>
-public record ResetEmailTemplateCommand : EmailTemplateQuery, IRequest
-{
-    /// <summary>
-    /// 
-    /// </summary>
-    /// <param name="orginal"></param>
-    public ResetEmailTemplateCommand(EmailTemplateQuery? orginal = null) : base(orginal ?? new())
-    {
-
-    }
-
-    /// <summary>
-    /// 
-    /// </summary>
-    /// <param name="Id">Die optionale ID der E-Mail-Vorlage, die zurückgesetzt werden soll.</param>
-    /// <param name="Type">Der Typ der E-Mail-Vorlage, z. B. <see cref="EmailTemplateType"/> (optional).</param>
-    public ResetEmailTemplateCommand(int? Id = null, EmailTemplateType? Type = null) : base(Id, Type)
-    {
-    }
-};

EnvelopeGenerator.Application/EmailTemplates/Commands/ResetEmailTemplateCommand.cs

@@ -1,11 +1,38 @@
 using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Domain.Constants;
+using MediatR;
 using EnvelopeGenerator.Application.Common.Dto;
 using EnvelopeGenerator.Domain.Entities;
-using MediatR;
 using Microsoft.EntityFrameworkCore;
-using System.Linq;
 
-namespace EnvelopeGenerator.Application.EmailTemplates.Commands.Reset;
+namespace EnvelopeGenerator.Application.EmailTemplates.Commands;
+
+/// <summary>
+/// Ein Befehl zum Zurücksetzen einer E-Mail-Vorlage auf die Standardwerte.
+/// Erbt von <see cref="IEmailTemplateQuery"/> und ermöglicht die Angabe einer optionalen ID und eines Typs der E-Mail-Vorlage.<br/><br/>
+/// </summary>
+public record ResetEmailTemplateCommand : IEmailTemplateQuery, IRequest
+{
+    /// <summary>
+    /// Die eindeutige Kennung der E-Mail-Vorlage (optional).
+    /// </summary>
+    public int? Id { get; set; }
+
+    /// <summary>
+    /// Der Typ der E-Mail-Vorlage, z. B. <see cref="EmailTemplateType"/> (optional). Beispiele:<br/>
+    /// 0 - DocumentReceived: Benachrichtigung über den Empfang eines Dokuments.<br/>
+    /// 1 - DocumentSigned: Benachrichtigung über die Unterzeichnung eines Dokuments.<br/>
+    /// 2 - DocumentDeleted: Benachrichtigung über das Löschen eines Dokuments.<br/>
+    /// 3 - DocumentCompleted: Benachrichtigung über den Abschluss eines Dokuments.<br/>
+    /// 4 - DocumentAccessCodeReceived: Benachrichtigung über den Erhalt eines Zugangscodes.<br/>
+    /// 5 - DocumentShared: Benachrichtigung über das Teilen eines Dokuments.<br/>
+    /// 6 - TotpSecret: Benachrichtigung über ein TOTP-Geheimnis.<br/>
+    /// 7 - DocumentRejected_ADM (für den Absender): Mail an den Absender, wenn das Dokument abgelehnt wird.<br/>
+    /// 8 - DocumentRejected_REC (für den ablehnenden Empfänger): Mail an den ablehnenden Empfänger, wenn das Dokument abgelehnt wird.<br/>
+    /// 9 - DocumentRejected_REC_2 (für sonstige Empfänger): Mail an andere Empfänger (Brief), wenn das Dokument abgelehnt wird.
+    /// </summary>
+    public EmailTemplateType? Type { get; set; }
+}
 
 /// <summary>
 /// 
@@ -41,7 +68,7 @@ public class ResetEmailTemplateCommandHandler : IRequestHandler<ResetEmailTempla
         foreach (var temp in temps)
         {
             var def = Defaults.Where(t => t.Name == temp.Name).FirstOrDefault();
-            if(def is not null)
+            if (def is not null)
                 await _repository.UpdateAsync(def, t => t.Id == temp.Id, cancel);
         }
     }
@@ -113,4 +140,4 @@ public class ResetEmailTemplateCommandHandler : IRequestHandler<ResetEmailTempla
         }
     };
 
-}
+}

EnvelopeGenerator.Application/EmailTemplates/Commands/Update/UpdateEmailTemplateCommand.cs

@@ -1,29 +0,0 @@
-using MediatR;
-using System.Text.Json.Serialization;
-
-namespace EnvelopeGenerator.Application.EmailTemplates.Commands.Update;
-
-
-/// <summary>
-/// Befehl zum Aktualisieren einer E-Mail-Vorlage.
-/// </summary>
-/// <param name="Body">
-/// (Optional)Der neue Inhalt des E-Mail-Textkörpers. Wenn null, bleibt der vorhandene Inhalt unverändert.
-/// </param>
-/// <param name="Subject">
-/// (Optional) Der neue Betreff der E-Mail. Wenn null, bleibt der vorhandene Betreff unverändert.
-/// </param>
-public record UpdateEmailTemplateCommand(string? Body = null, string? Subject = null) : IRequest
-{
-    /// <param>
-    /// Die Abfrage, die die E-Mail-Vorlage darstellt, die aktualisiert werden soll.
-    /// </param>
-    [JsonIgnore]
-    public EmailTemplateQuery? EmailTemplateQuery { get; set; }
-
-    /// <summary>
-    /// 
-    /// </summary>
-    [JsonIgnore]
-    public DateTime ChangedWhen { get; init; } = DateTime.Now;
-}

EnvelopeGenerator.Application/EmailTemplates/Commands/Update/UpdateEmailTemplateCommandHandler.cs

@@ -1,72 +0,0 @@
-using AutoMapper;
-using DigitalData.Core.Abstraction.Application.Repository;
-using DigitalData.Core.Exceptions;
-using EnvelopeGenerator.Domain.Entities;
-using MediatR;
-using Microsoft.EntityFrameworkCore;
-using EnvelopeGenerator.Domain.Constants;
-using EnvelopeGenerator.Application.Common.Dto;
-
-namespace EnvelopeGenerator.Application.EmailTemplates.Commands.Update;
-
-/// <summary>
-/// 
-/// </summary>
-public class UpdateEmailTemplateCommandHandler : IRequestHandler<UpdateEmailTemplateCommand>
-{
-    private readonly IRepository<EmailTemplate> _repository;
-    
-    private readonly IMapper _mapper;
-
-    /// <summary>
-    /// 
-    /// </summary>
-    /// <param name="repository"></param>
-    public UpdateEmailTemplateCommandHandler(IRepository<EmailTemplate> repository, IMapper mapper)
-    {
-        _repository = repository;
-        _mapper = mapper;
-    }
-
-    /// <summary>
-    /// 
-    /// </summary>
-    /// <param name="request"></param>
-    /// <param name="cancel"></param>
-    /// <returns></returns>
-    /// <exception cref="InvalidOperationException"></exception>
-    /// <exception cref="NotFoundException"></exception>
-    [Obsolete("Use Read-method returning IReadQuery<TEntity> instead.")]
-    public async Task Handle(UpdateEmailTemplateCommand request, CancellationToken cancel)
-    {
-        EmailTemplateDto? tempDto;
-
-        if (request.EmailTemplateQuery?.Id is int id)
-        {
-            var temp = await _repository.ReadOnly().Where(t => t.Id == id).FirstOrDefaultAsync(cancel);
-            tempDto = _mapper.Map<EmailTemplateDto>(temp);
-        }
-        else if (request!.EmailTemplateQuery!.Type is EmailTemplateType type)
-        {
-            var temp = await _repository.ReadOnly().Where(t => t.Name == type.ToString()).FirstOrDefaultAsync(cancel);
-            tempDto = _mapper.Map<EmailTemplateDto>(temp);
-        }
-        else
-        {
-            throw new InvalidOperationException("Both id and type is null. Id: " + request.EmailTemplateQuery.Id +". Type: " + request.EmailTemplateQuery.Type.ToString());
-        }
-
-        if (tempDto == null)
-        {
-            throw new NotFoundException();
-        }
-
-        if (request.Body is not null)
-            tempDto.Body = request.Body;
-
-        if (request.Subject is not null)
-            tempDto.Subject = request.Subject;
-
-        await _repository.UpdateAsync(tempDto, t => t.Id == tempDto.Id, cancel);
-    }
-}

EnvelopeGenerator.Application/EmailTemplates/Commands/UpdateEmailTemplateCommand.cs

@@ -0,0 +1,63 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Application.Common.Commands;
+using EnvelopeGenerator.Domain.Constants;
+using EnvelopeGenerator.Domain.Entities;
+using System.Linq.Expressions;
+
+namespace EnvelopeGenerator.Application.EmailTemplates.Commands;
+
+/// <summary>
+/// 
+/// </summary>
+/// <param name="Body"></param>
+/// <param name="Subject"></param>
+public record EmailTemplateUpdateDto(string Body, string Subject);
+
+/// <summary>
+/// Befehl zum Aktualisieren einer E-Mail-Vorlage.
+/// </summary>
+public record UpdateEmailTemplateCommand : UpdateCommand<EmailTemplateUpdateDto, EmailTemplate>, IEmailTemplateQuery
+{
+    /// <summary>
+    /// Die eindeutige Kennung der E-Mail-Vorlage (optional).
+    /// </summary>
+    public int? Id { get; set; }
+
+    /// <summary>
+    /// Der Typ der E-Mail-Vorlage, z. B. <see cref="EmailTemplateType"/> (optional). Beispiele:<br/>
+    /// 0 - DocumentReceived: Benachrichtigung über den Empfang eines Dokuments.<br/>
+    /// 1 - DocumentSigned: Benachrichtigung über die Unterzeichnung eines Dokuments.<br/>
+    /// 2 - DocumentDeleted: Benachrichtigung über das Löschen eines Dokuments.<br/>
+    /// 3 - DocumentCompleted: Benachrichtigung über den Abschluss eines Dokuments.<br/>
+    /// 4 - DocumentAccessCodeReceived: Benachrichtigung über den Erhalt eines Zugangscodes.<br/>
+    /// 5 - DocumentShared: Benachrichtigung über das Teilen eines Dokuments.<br/>
+    /// 6 - TotpSecret: Benachrichtigung über ein TOTP-Geheimnis.<br/>
+    /// 7 - DocumentRejected_ADM (für den Absender): Mail an den Absender, wenn das Dokument abgelehnt wird.<br/>
+    /// 8 - DocumentRejected_REC (für den ablehnenden Empfänger): Mail an den ablehnenden Empfänger, wenn das Dokument abgelehnt wird.<br/>
+    /// 9 - DocumentRejected_REC_2 (für sonstige Empfänger): Mail an andere Empfänger (Brief), wenn das Dokument abgelehnt wird.
+    /// </summary>
+    public EmailTemplateType? Type { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <returns></returns>
+    public override Expression<Func<EmailTemplate, bool>> BuildQueryExpression()
+        => Id is int id
+            ? temp => temp.Id == id
+            : temp => temp!.Name == Type.ToString();
+}
+
+/// <summary>
+/// 
+/// </summary>
+public class UpdateEmailTemplateCommandHandler : UpdateCommandHandler<UpdateEmailTemplateCommand, EmailTemplateUpdateDto, EmailTemplate>
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="repository"></param>
+    public UpdateEmailTemplateCommandHandler(IRepository<EmailTemplate> repository) : base(repository)
+    {
+    }
+}

EnvelopeGenerator.Application/EmailTemplates/EmailTemplateQuery.cs

@@ -1,24 +0,0 @@
-using EnvelopeGenerator.Domain.Constants;
-
-namespace EnvelopeGenerator.Application.EmailTemplates;
-
-/// <summary>
-/// Repräsentiert eine Abfrage für E-Mail-Vorlagen, die für Absender und Empfänger von Umschlägen verwendet werden.
-/// Die Standardkultur ist "de-DE".
-/// </summary>
-/// <param name="Id">Die eindeutige Kennung der E-Mail-Vorlage (optional).</param>
-/// <param name="Type">Der Typ der E-Mail-Vorlage, z. B. <see cref="EmailTemplateType"/> (optional). Beispiele:
-/// 0 - DocumentReceived: Benachrichtigung über den Empfang eines Dokuments.
-/// 1 - DocumentSigned: Benachrichtigung über die Unterzeichnung eines Dokuments.
-/// 2 - DocumentDeleted: Benachrichtigung über das Löschen eines Dokuments.
-/// 3 - DocumentCompleted: Benachrichtigung über den Abschluss eines Dokuments.
-/// 4 - DocumentAccessCodeReceived: Benachrichtigung über den Erhalt eines Zugangscodes.
-/// 5 - DocumentShared: Benachrichtigung über das Teilen eines Dokuments.
-/// 6 - TotpSecret: Benachrichtigung über ein TOTP-Geheimnis.
-/// 7 - DocumentRejected_ADM (Für den Absender): Mail an den Absender, wenn das Dokument abgelehnt wird.
-/// 8 - DocumentRejected_REC (Für den ablehnenden Empfänger): Mail an den ablehnenden Empfänger, wenn das Dokument abgelehnt wird.
-/// 9 - DocumentRejected_REC_2 (Für sonstige Empfänger): Mail an andere Empfänger (Brief), wenn das Dokument abgelehnt wird.
-/// </param>
-public record EmailTemplateQuery(int? Id = null, EmailTemplateType? Type = null)
-{
-}

EnvelopeGenerator.Application/EmailTemplates/IEmailTemplateQuery.cs

@@ -0,0 +1,30 @@
+using EnvelopeGenerator.Domain.Constants;
+
+namespace EnvelopeGenerator.Application.EmailTemplates;
+
+/// <summary>
+/// Stellt eine Schnittstelle für Abfragen von E-Mail-Vorlagen dar, die für Absender und Empfänger von Umschlägen verwendet werden.
+/// Die Standardkultur ist "de-DE".
+/// </summary>
+public interface IEmailTemplateQuery
+{
+    /// <summary>
+    /// Die eindeutige Kennung der E-Mail-Vorlage (optional).
+    /// </summary>
+    int? Id { get; set; }
+
+    /// <summary>
+    /// Der Typ der E-Mail-Vorlage, z. B. <see cref="EmailTemplateType"/> (optional). Beispiele:<br/>
+    /// 0 - DocumentReceived: Benachrichtigung über den Empfang eines Dokuments.<br/>
+    /// 1 - DocumentSigned: Benachrichtigung über die Unterzeichnung eines Dokuments.<br/>
+    /// 2 - DocumentDeleted: Benachrichtigung über das Löschen eines Dokuments.<br/>
+    /// 3 - DocumentCompleted: Benachrichtigung über den Abschluss eines Dokuments.<br/>
+    /// 4 - DocumentAccessCodeReceived: Benachrichtigung über den Erhalt eines Zugangscodes.<br/>
+    /// 5 - DocumentShared: Benachrichtigung über das Teilen eines Dokuments.<br/>
+    /// 6 - TotpSecret: Benachrichtigung über ein TOTP-Geheimnis.<br/>
+    /// 7 - DocumentRejected_ADM (für den Absender): Mail an den Absender, wenn das Dokument abgelehnt wird.<br/>
+    /// 8 - DocumentRejected_REC (für den ablehnenden Empfänger): Mail an den ablehnenden Empfänger, wenn das Dokument abgelehnt wird.<br/>
+    /// 9 - DocumentRejected_REC_2 (für sonstige Empfänger): Mail an andere Empfänger (Brief), wenn das Dokument abgelehnt wird.
+    /// </summary>
+    EmailTemplateType? Type { get; set; }
+}

EnvelopeGenerator.Application/EmailTemplates/MappingProfile.cs

@@ -1,24 +1,24 @@
-using AutoMapper;
-using EnvelopeGenerator.Application.EmailTemplates.Queries.Read;
+using AutoMapper;
+using EnvelopeGenerator.Application.Common.Dto;
+using EnvelopeGenerator.Application.Common.Extensions;
+using EnvelopeGenerator.Application.EmailTemplates.Commands;
 using EnvelopeGenerator.Domain.Entities;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace EnvelopeGenerator.Application.EmailTemplates;
 
 /// <summary>
-/// 
+///
 /// </summary>
 public class MappingProfile : Profile
 {
     /// <summary>
-    /// 
+    ///
     /// </summary>
     public MappingProfile()
     {
-        CreateMap<EmailTemplate, ReadEmailTemplateResponse>();
+        CreateMap<EmailTemplate, EmailTemplateDto>();
+
+        CreateMap<EmailTemplateUpdateDto, EmailTemplate>()
+            .MapChangedWhen();
     }
-}
+}

EnvelopeGenerator.Application/EmailTemplates/Queries/Read/ReadEmailTemplateQuery.cs

@@ -1,12 +0,0 @@
-using MediatR;
-
-namespace EnvelopeGenerator.Application.EmailTemplates.Queries.Read;
-
-
-/// <summary>
-/// Stellt eine Abfrage dar, um eine E-Mail-Vorlage zu lesen.
-/// Diese Klasse erbt von <see cref="EmailTemplateQuery"/>.
-/// </summary>
-public record ReadEmailTemplateQuery : EmailTemplateQuery, IRequest<ReadEmailTemplateResponse?>
-{
-}

EnvelopeGenerator.Application/EmailTemplates/Queries/Read/ReadEmailTemplateQueryHandler.cs

@@ -1,52 +0,0 @@
-using AutoMapper;
-using EnvelopeGenerator.Application.Common.Interfaces.Repositories;
-using EnvelopeGenerator.Domain.Constants;
-using MediatR;
-
-namespace EnvelopeGenerator.Application.EmailTemplates.Queries.Read;
-
-/// <summary>
-/// 
-/// </summary>
-public class ReadEmailTemplateQueryHandler : IRequestHandler<ReadEmailTemplateQuery, ReadEmailTemplateResponse?>
-{
-    private readonly IMapper _mapper;
-
-    [Obsolete("Use Read-method returning IReadQuery<TEntity> instead.")]
-    private readonly IEmailTemplateRepository _repository;
-
-    /// <summary>
-    /// Initialisiert eine neue Instanz der <see cref="EmailTemplateController"/>-Klasse.
-    /// </summary>
-    /// <param name="mapper">
-    /// <param name="repository">
-    /// Die AutoMapper-Instanz, die zum Zuordnen von Objekten verwendet wird.
-    /// </param>
-    [Obsolete("Use Read-method returning IReadQuery<TEntity> instead.")]
-    public ReadEmailTemplateQueryHandler(IMapper mapper, IEmailTemplateRepository repository)
-    {
-        _mapper = mapper;
-        _repository = repository;
-    }
-
-    /// <summary>
-    /// 
-    /// </summary>
-    /// <param name="request"></param>
-    /// <param name="cancellationToken"></param>
-    /// <returns></returns>
-    /// <exception cref="InvalidOperationException"></exception>
-    [Obsolete("Use IRepository")]
-    public async Task<ReadEmailTemplateResponse?> Handle(ReadEmailTemplateQuery request, CancellationToken cancellationToken)
-    {
-        var temp = request.Id is int id
-            ? await _repository.ReadByIdAsync(id)
-            : request.Type is EmailTemplateType type
-                ? await _repository.ReadByNameAsync(type)
-                : throw new InvalidOperationException("Either a valid integer ID or a valid EmailTemplateType must be provided in the request.");
-
-        var res = _mapper.Map<ReadEmailTemplateResponse>(temp);
-
-        return res;
-    }
-}

EnvelopeGenerator.Application/EmailTemplates/Queries/Read/ReadEmailTemplateResponse.cs

@@ -1,37 +0,0 @@
-namespace EnvelopeGenerator.Application.EmailTemplates.Queries.Read;
-
-/// <summary>
-/// Stellt die Antwort für eine Abfrage von E-Mail-Vorlagen bereit.
-/// </summary>
-public class ReadEmailTemplateResponse
-{
-    /// <summary>
-    /// Die eindeutige Kennung der E-Mail-Vorlage.
-    /// </summary>
-    public int Id { get; set; }
-
-    /// <summary>
-    /// Name des Typs
-    /// </summary>
-    public required string Name { get; set; }
-
-    /// <summary>
-    /// Das Datum und die Uhrzeit, wann die Vorlage hinzugefügt wurde.
-    /// </summary>
-    public DateTime AddedWhen { get; set; }
-
-    /// <summary>
-    /// Der Inhalt (Body) der E-Mail-Vorlage. Kann null sein.
-    /// </summary>
-    public string? Body { get; set; }
-
-    /// <summary>
-    /// Der Betreff der E-Mail-Vorlage. Kann null sein.
-    /// </summary>
-    public string? Subject { get; set; }
-
-    /// <summary>
-    /// Das Datum und die Uhrzeit, wann die Vorlage zuletzt geändert wurde. Kann null sein.
-    /// </summary>
-    public DateTime? ChangedWhen { get; set; }
-}

EnvelopeGenerator.Application/EmailTemplates/Queries/ReadEmailTemplateQuery.cs

@@ -0,0 +1,78 @@
+using AutoMapper;
+using MediatR;
+using EnvelopeGenerator.Application.Common.Dto;
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Domain.Entities;
+using Microsoft.EntityFrameworkCore;
+using EnvelopeGenerator.Domain.Constants;
+using DigitalData.Core.Exceptions;
+
+namespace EnvelopeGenerator.Application.EmailTemplates.Queries;
+
+/// <summary>
+/// Stellt eine Abfrage dar, um eine E-Mail-Vorlage zu lesen.
+/// Diese Klasse erbt von <see cref="IEmailTemplateQuery"/>.
+/// </summary>
+public record ReadEmailTemplateQuery : IEmailTemplateQuery, IRequest<EmailTemplateDto>
+{
+    /// <summary>
+    /// Die eindeutige Kennung der E-Mail-Vorlage (optional).
+    /// </summary>
+    public int? Id { get; set; }
+
+    /// <summary>
+    /// Der Typ der E-Mail-Vorlage, z. B. <see cref="EmailTemplateType"/> (optional). Beispiele:<br/>
+    /// 0 - DocumentReceived: Benachrichtigung über den Empfang eines Dokuments.<br/>
+    /// 1 - DocumentSigned: Benachrichtigung über die Unterzeichnung eines Dokuments.<br/>
+    /// 2 - DocumentDeleted: Benachrichtigung über das Löschen eines Dokuments.<br/>
+    /// 3 - DocumentCompleted: Benachrichtigung über den Abschluss eines Dokuments.<br/>
+    /// 4 - DocumentAccessCodeReceived: Benachrichtigung über den Erhalt eines Zugangscodes.<br/>
+    /// 5 - DocumentShared: Benachrichtigung über das Teilen eines Dokuments.<br/>
+    /// 6 - TotpSecret: Benachrichtigung über ein TOTP-Geheimnis.<br/>
+    /// 7 - DocumentRejected_ADM (für den Absender): Mail an den Absender, wenn das Dokument abgelehnt wird.<br/>
+    /// 8 - DocumentRejected_REC (für den ablehnenden Empfänger): Mail an den ablehnenden Empfänger, wenn das Dokument abgelehnt wird.<br/>
+    /// 9 - DocumentRejected_REC_2 (für sonstige Empfänger): Mail an andere Empfänger (Brief), wenn das Dokument abgelehnt wird.
+    /// </summary>
+    public EmailTemplateType? Type { get; set; }
+}
+
+/// <summary>
+/// 
+/// </summary>
+public class ReadEmailTemplateQueryHandler : IRequestHandler<ReadEmailTemplateQuery, EmailTemplateDto>
+{
+    private readonly IMapper _mapper;
+
+    private readonly IRepository<EmailTemplate> _repo;
+
+    /// <summary>
+    /// Initialisiert eine neue Instanz der <see cref="EmailTemplateController"/>-Klasse.
+    /// </summary>
+    /// <param name="mapper">
+    /// <param name="repo">
+    /// Die AutoMapper-Instanz, die zum Zuordnen von Objekten verwendet wird.
+    /// </param>
+    public ReadEmailTemplateQueryHandler(IMapper mapper, IRepository<EmailTemplate> repo)
+    {
+        _mapper = mapper;
+        _repo = repo;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancel"></param>
+    /// <returns></returns>
+    /// <exception cref="InvalidOperationException"></exception>
+    public async Task<EmailTemplateDto> Handle(ReadEmailTemplateQuery request, CancellationToken cancel)
+    {
+        var query = request.Id is int id
+            ? _repo.Query.Where(temp => temp.Id == id)
+            : _repo.Query.Where(temp => temp.Name == request.Type!.ToString());
+
+        var entity = await query.FirstOrDefaultAsync(cancel) ?? throw new NotFoundException();
+
+        return _mapper.Map<EmailTemplateDto>(entity);
+    }
+}

EnvelopeGenerator.Application/EnvelopeGenerator.Application.csproj

@@ -14,7 +14,7 @@
 
 	<ItemGroup>
 		<PackageReference Include="Dapper" Version="2.1.66" />
-		<PackageReference Include="DigitalData.Core.Abstraction.Application" Version="1.3.1" />
+		<PackageReference Include="DigitalData.Core.Abstraction.Application" Version="1.6.0" />
 		<PackageReference Include="DigitalData.Core.Application" Version="3.4.0" />
 		<PackageReference Include="DigitalData.Core.Client" Version="2.1.0" />
 		<PackageReference Include="DigitalData.Core.Exceptions" Version="1.1.0" />

EnvelopeGenerator.Application/EnvelopeReceivers/Queries/ReadEnvelopeReceiverQuery.cs

@@ -1,4 +1,4 @@
-using AutoMapper;
+using AutoMapper;
 using DigitalData.Core.Abstraction.Application.Repository;
 using DigitalData.Core.Exceptions;
 using EnvelopeGenerator.Application.Envelopes.Queries;
@@ -47,7 +47,13 @@ namespace EnvelopeGenerator.Application.EnvelopeReceivers.Queries;
 /// Die Antwort enthält Details wie den Include, die Zuordnung zwischen Umschlag und Empfänger 
 /// sowie zusätzliche Metadaten.
 /// </remarks>
-public record ReadEnvelopeReceiverQuery : EnvelopeReceiverQueryBase<ReadEnvelopeQuery, ReadReceiverQuery>, IRequest<IEnumerable<EnvelopeReceiverDto>>;
+public record ReadEnvelopeReceiverQuery : EnvelopeReceiverQueryBase<ReadEnvelopeQuery, ReadReceiverQuery>, IRequest<IEnumerable<EnvelopeReceiverDto>>
+{
+    /// <summary>
+    /// Optionaler Benutzernamefilter, um Ergebnisse auf Umschläge eines bestimmten Besitzers einzuschränken.
+    /// </summary>
+    public string? Username { get; init; }
+}
 
 /// <summary>
 /// 
@@ -61,10 +67,11 @@ public static class Extensions
     /// <param name="key"></param>
     /// <param name="cancel"></param>
     /// <returns></returns>
-    public static Task<EnvelopeReceiverDto?> ReadEnvelopeReceiverAsync(this IMediator mediator, string key, CancellationToken cancel = default)
+    public static async Task<EnvelopeReceiverDto?> ReadEnvelopeReceiverAsync(this IMediator mediator, string key, CancellationToken cancel = default)
     {
         var q = new ReadEnvelopeReceiverQuery() { Key = key };
-        return mediator.Send(q, cancel).Then(envRcvs => envRcvs.FirstOrDefault());
+        var envRcvs = await mediator.Send(q, cancel);
+        return envRcvs.FirstOrDefault();
     }
 
     /// <summary>
@@ -75,80 +82,82 @@ public static class Extensions
     /// <param name="signature"></param>
     /// <param name="cancel"></param>
     /// <returns></returns>
-    public static Task<EnvelopeReceiverDto?> ReadEnvelopeReceiverAsync(this IMediator mediator, string uuid, string signature, CancellationToken cancel = default)
+    public static async Task<EnvelopeReceiverDto?> ReadEnvelopeReceiverAsync(this IMediator mediator, string uuid, string signature, CancellationToken cancel = default)
     {
         var q = new ReadEnvelopeReceiverQuery();
         q.Envelope.Uuid = uuid;
         q.Receiver.Signature = signature;
-        return mediator.Send(q, cancel).Then(envRcvs => envRcvs.FirstOrDefault());
+        var envRcvs = await mediator.Send(q, cancel);
+        return envRcvs.FirstOrDefault();
     }
-}
-
-/// <summary>
-/// 
-/// </summary>
-public class ReadEnvelopeReceiverQueryHandler : IRequestHandler<ReadEnvelopeReceiverQuery, IEnumerable<EnvelopeReceiverDto>>
-{
-    private readonly IRepository<EnvelopeReceiver> _repo;
-
-    private readonly IRepository<Receiver> _rcvRepo;
-
-    private readonly IMapper _mapper;
-
     /// <summary>
-    /// 
+    /// Verarbeitet <see cref="ReadEnvelopeReceiverQuery"/> und liefert passende <see cref="EnvelopeReceiverDto"/>-Ergebnisse.
     /// </summary>
-    /// <param name="envelopeReceiver"></param>
-    /// <param name="mapper"></param>
-    public ReadEnvelopeReceiverQueryHandler(IRepository<EnvelopeReceiver> envelopeReceiver, IRepository<Receiver> rcvRepo, IMapper mapper)
+    public class ReadEnvelopeReceiverQueryHandler : IRequestHandler<ReadEnvelopeReceiverQuery, IEnumerable<EnvelopeReceiverDto>>
     {
-        _repo = envelopeReceiver;
-        _mapper = mapper;
-        _rcvRepo = rcvRepo;
-    }
+        private readonly IRepository<EnvelopeReceiver> _repo;
+        private readonly IRepository<Receiver> _rcvRepo;
+        private readonly IMapper _mapper;
 
-    /// <summary>
-    /// 
-    /// </summary>
-    /// <param name="request"></param>
-    /// <param name="cancel"></param>
-    /// <returns></returns>
-    /// <exception cref="BadRequestException"></exception>
-    public async Task<IEnumerable<EnvelopeReceiverDto>> Handle(ReadEnvelopeReceiverQuery request, CancellationToken cancel)
-    {
-        var q = _repo.ReadOnly().Where(request, notnull: false);
-
-        if (request.Envelope.Status is not null)
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="envelopeReceiver"></param>
+        /// <param name="rcvRepo"></param>
+        /// <param name="mapper"></param>
+        public ReadEnvelopeReceiverQueryHandler(IRepository<EnvelopeReceiver> envelopeReceiver, IRepository<Receiver> rcvRepo, IMapper mapper)
         {
-            var status = request.Envelope.Status;
-            if (status.Min is not null)
-                q = q.Where(er => er.Envelope!.Status >= status.Min);
-
-            if (status.Max is not null)
-                q = q.Where(er => er.Envelope!.Status <= status.Max);
-
-            if (status.Include?.Length > 0)
-                q = q.Where(er => status.Include.Contains(er.Envelope!.Status));
-
-            if (status.Ignore is not null)
-                q = q.Where(er => !status.Ignore.Contains(er.Envelope!.Status));
+            _repo = envelopeReceiver;
+            _mapper = mapper;
+            _rcvRepo = rcvRepo;
         }
 
-        var envRcvs = await q
-                        .Include(er => er.Envelope).ThenInclude(e => e!.Documents!).ThenInclude(d => d.Elements)
-                        .Include(er => er.Envelope).ThenInclude(e => e!.Histories)
-                        .Include(er => er.Envelope).ThenInclude(e => e!.User)
-                        .Include(er => er.Receiver)
-                        .ToListAsync(cancel);
-
-        if (request.Receiver.HasAnyCriteria && envRcvs.Any())
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="cancel"></param>
+        /// <returns></returns>
+        /// <exception cref="BadRequestException"></exception>
+        public async Task<IEnumerable<EnvelopeReceiverDto>> Handle(ReadEnvelopeReceiverQuery request, CancellationToken cancel)
         {
-            var receiver = await _rcvRepo.ReadOnly().Where(request.Receiver).FirstAsync(cancel);
+            var q = _repo.Query.Where(request, notnull: false);
 
-            foreach (var envRcv in envRcvs)
-                envRcv.Envelope?.Documents?.First().Elements.RemoveAll(s => s.ReceiverId != receiver.Id);
+            if (request.Username is string username)
+                q = q.Where(er => er.Envelope!.User.Username == username);
+
+            if (request.Envelope.Status is not null)
+            {
+                var status = request.Envelope.Status;
+                if (status.Min is not null)
+                    q = q.Where(er => er.Envelope!.Status >= status.Min);
+
+                if (status.Max is not null)
+                    q = q.Where(er => er.Envelope!.Status <= status.Max);
+
+                if (status.Include?.Length > 0)
+                    q = q.Where(er => status.Include.Contains(er.Envelope!.Status));
+
+                if (status.Ignore is not null)
+                    q = q.Where(er => !status.Ignore.Contains(er.Envelope!.Status));
+            }
+
+            var envRcvs = await q
+                            .Include(er => er.Envelope).ThenInclude(e => e!.Documents!).ThenInclude(d => d.Elements)
+                            .Include(er => er.Envelope).ThenInclude(e => e!.Histories)
+                            .Include(er => er.Envelope).ThenInclude(e => e!.User)
+                            .Include(er => er.Receiver)
+                            .ToListAsync(cancel);
+
+            if (request.Receiver.HasAnyCriteria && envRcvs.Count != 0)
+            {
+                var receiver = await _rcvRepo.Query.Where(request.Receiver).FirstAsync(cancel);
+
+                foreach (var envRcv in envRcvs)
+                    envRcv.Envelope?.Documents?.FirstOrDefault()?.Elements?.RemoveAll(s => s.ReceiverId != receiver.Id);
+            }
+
+            return _mapper.Map<List<EnvelopeReceiverDto>>(envRcvs);
         }
-
-        return _mapper.Map<List<EnvelopeReceiverDto>>(envRcvs);
     }
-} 
+}

EnvelopeGenerator.Application/EnvelopeReceivers/Queries/ReceiverAlreadySignedQuery.cs

@@ -68,6 +68,6 @@ public class ReceiverAlreadySignedQueryHandler : IRequestHandler<ReceiverAlready
     /// <returns></returns>
     public async Task<bool> Handle(ReceiverAlreadySignedQuery request, CancellationToken cancel = default)
     {
-        return await _repo.ReadOnly().Where(request).Where(h => h.Status == EnvelopeStatus.DocumentSigned).AnyAsync(cancel);
+        return await _repo.Query.Where(request).Where(h => h.Status == EnvelopeStatus.DocumentSigned).AnyAsync(cancel);
     }
 }

EnvelopeGenerator.Application/EnvelopeTypes/Queries/ReadEnvelopeTypesQuery.cs

@@ -0,0 +1,45 @@
+using EnvelopeGenerator.Application.Common.Dto;
+using MediatR;
+using AutoMapper;
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Domain.Entities;
+using Microsoft.EntityFrameworkCore;
+
+namespace EnvelopeGenerator.Application.EnvelopeTypes.Queries;
+
+/// <summary>
+/// 
+/// </summary>
+public record ReadEnvelopeTypesQuery : IRequest<IEnumerable<EnvelopeTypeDto>>;
+
+/// <summary>
+/// 
+/// </summary>
+public class ReadEnvelopeTypesQueryHandler : IRequestHandler<ReadEnvelopeTypesQuery, IEnumerable<EnvelopeTypeDto>>
+{
+    private readonly IRepository<EnvelopeType> _repository;
+    private readonly IMapper _mapper;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="repository"></param>
+    /// <param name="mapper"></param>
+    public ReadEnvelopeTypesQueryHandler(IRepository<EnvelopeType> repository, IMapper mapper)
+    {
+        _repository = repository;
+        _mapper = mapper;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    public async Task<IEnumerable<EnvelopeTypeDto>> Handle(ReadEnvelopeTypesQuery request, CancellationToken cancellationToken)
+    {
+        var types = await _repository.Query.ToListAsync(cancellationToken);
+        return _mapper.Map<IEnumerable<EnvelopeTypeDto>>(types);
+    }
+}

EnvelopeGenerator.Application/Envelopes/Commands/CreateEnvelopeCommand.cs

@@ -33,7 +33,18 @@ public record CreateEnvelopeCommand : IRequest<EnvelopeDto?>
     /// <summary>
     /// ID des Absenders
     /// </summary>
-    public int UserId { get; set; }
+    internal int UserId { get; private set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="userId"></param>
+    /// <returns></returns>
+    public bool Authorize(int userId)
+    {
+        UserId = userId;
+        return true;
+    }
 
     /// <summary>
     /// Determines which component is used for envelope processing.

EnvelopeGenerator.Application/Envelopes/Queries/ReadEnvelopeQuery.cs

@@ -1,18 +1,33 @@
 using MediatR;
 using EnvelopeGenerator.Domain.Constants;
 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 Umschläge.
 /// </summary>
-public record ReadEnvelopeQuery : EnvelopeQueryBase, IRequest
+public record ReadEnvelopeQuery : EnvelopeQueryBase, IRequest<IEnumerable<EnvelopeDto>>
 {
     /// <summary>
     /// Abfrage des Include des Umschlags
     /// </summary>
     public EnvelopeStatusQuery? Status { get; init; }
+
+    /// <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 ReadEnvelopeQuery Authorize(int userId) => this with { UserId = userId };
 }
 
 /// <summary>
@@ -65,4 +80,62 @@ public record EnvelopeStatusQuery
     /// Eine Liste von Statuswerten, die ignoriert werden werden.
     /// </summary>
     public EnvelopeStatus[]? Ignore { get; init; }
+}
+
+/// <summary>
+/// Verarbeitet <see cref="ReadEnvelopeQuery"/> und liefert passende <see cref="EnvelopeDto"/>-Ergebnisse.
+/// </summary>
+public class ReadEnvelopeQueryHandler : IRequestHandler<ReadEnvelopeQuery, IEnumerable<EnvelopeDto>>
+{
+    private readonly IRepository<Envelope> _repository;
+    private readonly IMapper _mapper;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="repository"></param>
+    /// <param name="mapper"></param>
+    public ReadEnvelopeQueryHandler(IRepository<Envelope> repository, IMapper mapper)
+    {
+        _repository = repository;
+        _mapper = mapper;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancel"></param>
+    /// <returns></returns>
+    public async Task<IEnumerable<EnvelopeDto>> Handle(ReadEnvelopeQuery 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);
+
+        if (request.Status is { } status)
+        {
+            if (status.Min is not null)
+                query = query.Where(e => e.Status >= status.Min);
+            if (status.Max is not null)
+                query = query.Where(e => e.Status <= status.Max);
+            if (status.Include?.Length > 0)
+                query = query.Where(e => status.Include.Contains(e.Status));
+            if (status.Ignore?.Length > 0)
+                query = query.Where(e => !status.Ignore.Contains(e.Status));
+        }
+
+        var envelopes = await query
+            .Include(e => e.Documents)
+            .ToListAsync(cancel);
+
+        return _mapper.Map<IEnumerable<EnvelopeDto>>(envelopes);
+    }
 }

EnvelopeGenerator.Application/Envelopes/Queries/ReadReceiverNameQuery.cs

@@ -1,4 +1,8 @@
-using EnvelopeGenerator.Application.Receivers.Queries;
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Application.Common.Query;
+using MediatR;
+using EnvelopeGenerator.Domain.Entities;
+using Microsoft.EntityFrameworkCore;
 
 namespace EnvelopeGenerator.Application.Envelopes.Queries;
 
@@ -6,6 +10,54 @@ namespace EnvelopeGenerator.Application.Envelopes.Queries;
 /// Eine Abfrage, um die zuletzt verwendete Anrede eines Empfängers zu ermitteln, 
 /// damit diese für zukünftige Umschläge wiederverwendet werden kann.
 /// </summary>
-public record ReadReceiverNameQuery() : ReadReceiverQuery
+public record ReadReceiverNameQuery() : ReceiverQueryBase, IRequest<string?>;
+
+/// <summary>
+/// 
+/// </summary>
+public class ReadReceiverNameQueryHandler : IRequestHandler<ReadReceiverNameQuery, string?>
 {
-}
+    private readonly IRepository<EnvelopeReceiver> _envelopeReceiverRepository;
+    private readonly IRepository<Receiver> _receiverRepository;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="envelopeReceiverRepository"></param>
+    /// <param name="receiverRepository"></param>
+    public ReadReceiverNameQueryHandler(IRepository<EnvelopeReceiver> envelopeReceiverRepository, IRepository<Receiver> receiverRepository)
+    {
+        _envelopeReceiverRepository = envelopeReceiverRepository;
+        _receiverRepository = receiverRepository;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    public async Task<string?> Handle(ReadReceiverNameQuery request, CancellationToken cancellationToken)
+    {
+        var receiverQuery = _receiverRepository.Query.AsNoTracking();
+
+        if (request.Id is int id)
+            receiverQuery = receiverQuery.Where(r => r.Id == id);
+        if (request.EmailAddress is string email)
+            receiverQuery = receiverQuery.Where(r => r.EmailAddress == email);
+        if (request.Signature is string signature)
+            receiverQuery = receiverQuery.Where(r => r.Signature == signature);
+
+        var receiver = await receiverQuery.FirstOrDefaultAsync(cancellationToken);
+        if (receiver is null)
+            return null;
+
+        var erName = await _envelopeReceiverRepository.Query
+            .Where(er => er.ReceiverId == receiver.Id)
+            .OrderByDescending(er => er.AddedWhen)
+            .Select(er => er.Name)
+            .FirstOrDefaultAsync(cancellationToken);
+
+        return erName;
+    }
+}

EnvelopeGenerator.Application/Histories/Commands/CreateHistoryCommand.cs

@@ -82,7 +82,7 @@ public class CreateHistoryCommandHandler : IRequestHandler<CreateHistoryCommand,
         if(request.UserReference is null)
         {
             var receivers = await _erRepo
-                .ReadOnly()
+                .Query
                 .Where(request)
                 .Include(er => er.Receiver)
                 .ToListAsync(cancel);

EnvelopeGenerator.Application/Histories/Queries/CountHistoryQuery.cs

@@ -0,0 +1,101 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.Core.Exceptions;
+using EnvelopeGenerator.Domain.Constants;
+using EnvelopeGenerator.Domain.Entities;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+
+namespace EnvelopeGenerator.Application.Histories.Queries;
+
+//TODO: Add sender query
+/// <summary>
+/// Repräsentiert eine Abfrage für die Verlaufshistorie eines Umschlags.
+/// </summary>
+public record CountHistoryQuery : HistoryQueryBase, IRequest<int>;
+
+/// <summary>
+/// 
+/// </summary>
+public static class CountHistoryQueryExtensions
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="sender"></param>
+    /// <param name="uuid"></param>
+    /// <param name="statuses"></param>
+    /// <param name="cancel"></param>
+    /// <returns></returns>
+    public static async Task<bool> AnyHistoryAsync(this ISender sender, string uuid, IEnumerable<EnvelopeStatus> statuses, CancellationToken cancel = default)
+    {
+        var count = await sender.Send(new CountHistoryQuery
+        {
+            Envelope = new() { Uuid = uuid },
+            Statuses = new() { Include = statuses }
+        }, cancel);
+        return count > 0;
+    }
+}
+
+/// <summary>
+/// 
+/// </summary>
+public class CountHistoryQueryHandler : IRequestHandler<CountHistoryQuery, int>
+{
+    private readonly IRepository<History> _repo;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="repo"></param>
+    public CountHistoryQueryHandler(IRepository<History> repo)
+    {
+        _repo = repo;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancel"></param>
+    /// <returns></returns>
+    /// <exception cref="NotFoundException"></exception>
+    public Task<int> Handle(CountHistoryQuery request, CancellationToken cancel = default)
+    {
+        var query = _repo.Query;
+
+        if (request.Envelope.Id is int envId)
+            query = query.Where(e => e.Id == envId);
+        else if (request.Envelope.Uuid is string uuid)
+            query = query.Where(e => e.Envelope!.Uuid == uuid);
+#pragma warning disable CS0618 // Type or member is obsolete
+        else if (request.EnvelopeId is not null)
+            query = query.Where(h => h.EnvelopeId == request.EnvelopeId);
+#pragma warning restore CS0618 // Type or member is obsolete
+        else
+            throw new BadRequestException("Invalid request: An Envelope object or a valid EnvelopeId/UUID must be supplied.");
+
+#pragma warning disable CS0618 // Type or member is obsolete
+        if (request.Status is not null)
+            query = query.Where(h => h.Status == request.Status);
+#pragma warning restore CS0618 // Type or member is obsolete
+
+        if (request.Statuses is not null)
+        {
+            var status = request.Statuses;
+            if (status.Min is not null)
+                query = query.Where(er => er.Envelope!.Status >= status.Min);
+
+            if (status.Max is not null)
+                query = query.Where(er => er.Envelope!.Status <= status.Max);
+
+            if (status.Include?.Count() > 0)
+                query = query.Where(er => status.Include.Contains(er.Envelope!.Status));
+
+            if (status.Ignore is not null)
+                query = query.Where(er => !status.Ignore.Contains(er.Envelope!.Status));
+        }
+
+        return query.CountAsync(cancel);
+    }
+}

EnvelopeGenerator.Application/Histories/Queries/HistoryQueryBase.cs

@@ -0,0 +1,60 @@
+using EnvelopeGenerator.Application.Common.Query;
+using EnvelopeGenerator.Domain.Constants;
+using System.ComponentModel.DataAnnotations;
+
+namespace EnvelopeGenerator.Application.Histories.Queries;
+
+//TODO: Add sender query
+/// <summary>
+/// 
+/// </summary>
+public record HistoryQueryBase
+{
+    /// <summary>
+    /// Die eindeutige Kennung des Umschlags.
+    /// </summary>
+    [Obsolete("Use Envelope property")]
+    public int? EnvelopeId { get; set; }
+
+    /// <summary>
+    /// Der Include des Umschlags, der abgefragt werden soll. Kann optional angegeben werden, um die Ergebnisse zu filtern.
+    /// </summary>
+    [Obsolete("Use statuses")]
+    public EnvelopeStatus? Status { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public EnvelopeStatusQuery Statuses { get; set; } = new();
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public EnvelopeQueryBase Envelope { get; set; } = new EnvelopeQueryBase();
+}
+
+/// <summary>
+/// 
+/// </summary>
+public record EnvelopeStatusQuery
+{
+    /// <summary>
+    /// Der minimale Statuswert, der berücksichtigt werden.
+    /// </summary>
+    public EnvelopeStatus? Min { get; init; }
+
+    /// <summary>
+    /// Der maximale Statuswert, der berücksichtigt werden.
+    /// </summary>
+    public EnvelopeStatus? Max { get; init; }
+
+    /// <summary>
+    /// Eine Liste von Statuswerten, die einbezogen werden.
+    /// </summary>
+    public IEnumerable<EnvelopeStatus>? Include { get; init; }
+
+    /// <summary>
+    /// Eine Liste von Statuswerten, die ignoriert werden werden.
+    /// </summary>
+    public IEnumerable<EnvelopeStatus>? Ignore { get; init; }
+}

EnvelopeGenerator.Application/Histories/Queries/ReadHistoryQuery.cs

@@ -1,7 +1,10 @@
-using EnvelopeGenerator.Application.Common.Dto.History;
-using EnvelopeGenerator.Domain.Constants;
+using AutoMapper;
+using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.Core.Exceptions;
+using EnvelopeGenerator.Application.Common.Dto.History;
 using MediatR;
-using System.ComponentModel.DataAnnotations;
+using EnvelopeGenerator.Domain.Entities;
+using Microsoft.EntityFrameworkCore;
 
 namespace EnvelopeGenerator.Application.Histories.Queries;
 
@@ -9,21 +12,81 @@ namespace EnvelopeGenerator.Application.Histories.Queries;
 /// <summary>
 /// Repräsentiert eine Abfrage für die Verlaufshistorie eines Umschlags.
 /// </summary>
-public record ReadHistoryQuery : IRequest<IEnumerable<HistoryDto>>
+public record ReadHistoryQuery : HistoryQueryBase, IRequest<IEnumerable<HistoryDto>>
 {
-    /// <summary>
-    /// Die eindeutige Kennung des Umschlags.
-    /// </summary>
-    [Required]
-    public int EnvelopeId { get; init; }
-
-    /// <summary>
-    /// Der Include des Umschlags, der abgefragt werden soll. Kann optional angegeben werden, um die Ergebnisse zu filtern.
-    /// </summary>
-    public EnvelopeStatus? Status { get; init; }
-
     /// <summary>
     /// Abfrage zur Steuerung, ob nur der aktuelle Include oder der gesamte Datensatz zurückgegeben wird.
     /// </summary>
-    public bool? OnlyLast { get; init; } = true;
+    public bool OnlyLast { get; init; } = true;
+}
+
+/// <summary>
+/// 
+/// </summary>
+public class ReadHistoryQueryHandler : IRequestHandler<ReadHistoryQuery, IEnumerable<HistoryDto>>
+{
+    private readonly IRepository<History> _repo;
+
+    private readonly IMapper _mapper;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="repo"></param>
+    /// <param name="mapper"></param>
+    public ReadHistoryQueryHandler(IRepository<History> repo, IMapper mapper)
+    {
+        _repo = repo;
+        _mapper = mapper;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancel"></param>
+    /// <returns></returns>
+    /// <exception cref="NotFoundException"></exception>
+    public async Task<IEnumerable<HistoryDto>> Handle(ReadHistoryQuery request, CancellationToken cancel = default)
+    {
+        var query = _repo.Query;
+
+        if (request.Envelope.Id is int envId)
+            query = query.Where(e => e.Id == envId);
+        else if (request.Envelope.Uuid is string uuid)
+            query = query.Where(e => e.Envelope!.Uuid == uuid);
+#pragma warning disable CS0618 // Type or member is obsolete
+        else if (request.EnvelopeId is not null)
+            query = query.Where(h => h.EnvelopeId == request.EnvelopeId);
+#pragma warning restore CS0618 // Type or member is obsolete
+        else
+            throw new BadRequestException("Invalid request: An Envelope object or a valid EnvelopeId/UUID must be supplied.");
+
+#pragma warning disable CS0618 // Type or member is obsolete
+        if (request.Status is not null)
+            query = query.Where(h => h.Status == request.Status);
+#pragma warning restore CS0618 // Type or member is obsolete
+
+        if (request.Statuses is not null)
+        {
+            var status = request.Statuses;
+            if (status.Min is not null)
+                query = query.Where(er => er.Envelope!.Status >= status.Min);
+
+            if (status.Max is not null)
+                query = query.Where(er => er.Envelope!.Status <= status.Max);
+
+            if (status.Include?.Count() > 0)
+                query = query.Where(er => status.Include.Contains(er.Envelope!.Status));
+
+            if (status.Ignore is not null)
+                query = query.Where(er => !status.Ignore.Contains(er.Envelope!.Status));
+        }
+
+        if (request.OnlyLast)
+            query = query.OrderByDescending(x => x.AddedWhen);
+
+        var hists = await query.ToListAsync(cancel);
+        return _mapper.Map<List<HistoryDto>>(hists);
+    }
 }

EnvelopeGenerator.Application/Histories/Queries/ReadHistoryQueryHandler.cs

@@ -1,47 +0,0 @@
-using AutoMapper;
-using DigitalData.Core.Abstraction.Application.Repository;
-using DigitalData.Core.Exceptions;
-using EnvelopeGenerator.Application.Common.Dto.History;
-using EnvelopeGenerator.Domain.Entities;
-using MediatR;
-using Microsoft.EntityFrameworkCore;
-
-namespace EnvelopeGenerator.Application.Histories.Queries;
-
-/// <summary>
-/// 
-/// </summary>
-public class ReadHistoryQueryHandler : IRequestHandler<ReadHistoryQuery, IEnumerable<HistoryDto>>
-{
-    private readonly IRepository<History> _repo;
-
-    private readonly IMapper _mapper;
-
-    /// <summary>
-    /// 
-    /// </summary>
-    /// <param name="repo"></param>
-    /// <param name="mapper"></param>
-    public ReadHistoryQueryHandler(IRepository<History> repo, IMapper mapper)
-    {
-        _repo = repo;
-        _mapper = mapper;
-    }
-
-    /// <summary>
-    /// 
-    /// </summary>
-    /// <param name="request"></param>
-    /// <param name="cancel"></param>
-    /// <returns></returns>
-    /// <exception cref="NotFoundException"></exception>
-    public async Task<IEnumerable<HistoryDto>> Handle(ReadHistoryQuery request, CancellationToken cancel = default)
-    {
-        var query = _repo.ReadOnly().Where(h => h.EnvelopeId == request.EnvelopeId);
-        if (request.Status is not null)
-            query = query.Where(h => h.Status == request.Status);
-
-        var hists = await query.ToListAsync(cancel);
-        return _mapper.Map<List<HistoryDto>>(hists);
-    }
-}

EnvelopeGenerator.Application/Receivers/Commands/CreateReceiverCommand.cs

@@ -67,6 +67,7 @@ public class CreateReceiverCommandHandler : IRequestHandler<CreateReceiverComman
     /// 
     /// </summary>
     /// <param name="repo"></param>
+    /// <param name="mapper"></param>
     public CreateReceiverCommandHandler(IRepository<Receiver> repo, IMapper mapper)
     {
         _repo = repo;
@@ -81,7 +82,7 @@ public class CreateReceiverCommandHandler : IRequestHandler<CreateReceiverComman
     /// <returns></returns>
     public async Task<(ReceiverDto Receiver, bool AlreadyExists)> Handle(CreateReceiverCommand request, CancellationToken cancel)
     {
-        var receiver = await _repo.ReadOnly()
+        var receiver = await _repo.Query
             .Where(r => r.EmailAddress == request.EmailAddress)
             .SingleOrDefaultAsync(cancel);
 

EnvelopeGenerator.Application/Receivers/Queries/ReadReceiverQuery.cs

@@ -1,4 +1,10 @@
-using EnvelopeGenerator.Application.Common.Query;
+using AutoMapper;
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Application.Common.Dto.Receiver;
+using EnvelopeGenerator.Application.Common.Query;
+using MediatR;
+using EnvelopeGenerator.Domain.Entities;
+using Microsoft.EntityFrameworkCore;
 
 namespace EnvelopeGenerator.Application.Receivers.Queries;
 
@@ -6,4 +12,53 @@ namespace EnvelopeGenerator.Application.Receivers.Queries;
 /// Stellt eine Abfrage dar, um die Details eines Empfängers zu lesen.
 /// um spezifische Informationen über einen Empfänger abzurufen.
 /// </summary>
-public record ReadReceiverQuery : ReceiverQueryBase;
+public record ReadReceiverQuery : ReceiverQueryBase, IRequest<IEnumerable<ReceiverDto>>;
+
+/// <summary>
+/// 
+/// </summary>
+public class ReadReceiverQueryHandler : IRequestHandler<ReadReceiverQuery, IEnumerable<ReceiverDto>>
+{
+    private readonly IRepository<Receiver> _repository;
+    private readonly IMapper _mapper;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="repository"></param>
+    /// <param name="mapper"></param>
+    public ReadReceiverQueryHandler(IRepository<Receiver> repository, IMapper mapper)
+    {
+        _repository = repository;
+        _mapper = mapper;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    public async Task<IEnumerable<ReceiverDto>> Handle(ReadReceiverQuery request, CancellationToken cancellationToken)
+    {
+        var query = _repository.Query;
+
+        if (request.Id is int id)
+        {
+            query = query.Where(r => r.Id == id);
+        }
+
+        if (request.EmailAddress is string email)
+        {
+            query = query.Where(r => r.EmailAddress == email);
+        }
+
+        if (request.Signature is string signature)
+        {
+            query = query.Where(r => r.Signature == signature);
+        }
+
+        var receiver = await query.ToListAsync(cancellationToken);
+        return _mapper.Map<IEnumerable<ReceiverDto>>(receiver);
+    }
+}

EnvelopeGenerator.BBTests/EnvelopeGenerator.BBTests.vbproj

@@ -45,6 +45,9 @@
     <StartupObject>EnvelopeGenerator.My.MyApplication</StartupObject>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="AutoMapper, Version=10.0.0.0, Culture=neutral, PublicKeyToken=be96cd2c38ef1005, processorArchitecture=MSIL">
+      <HintPath>..\packages\AutoMapper.10.1.1\lib\net461\AutoMapper.dll</HintPath>
+    </Reference>
     <Reference Include="BouncyCastle.Cryptography, Version=2.0.0.0, Culture=neutral, PublicKeyToken=072edcf4a5328938, processorArchitecture=MSIL">
       <HintPath>..\packages\BouncyCastle.Cryptography.2.5.0\lib\net461\BouncyCastle.Cryptography.dll</HintPath>
     </Reference>
@@ -67,6 +70,12 @@
     <Reference Include="DigitalData.Controls.DocumentViewer, Version=1.9.8.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\packages\DigitalData.Controls.DocumentViewer.1.9.8\lib\net462\DigitalData.Controls.DocumentViewer.dll</HintPath>
     </Reference>
+    <Reference Include="DigitalData.Core.Abstraction.Application, Version=1.6.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\DigitalData.Core.Abstraction.Application.1.6.0\lib\net462\DigitalData.Core.Abstraction.Application.dll</HintPath>
+    </Reference>
+    <Reference Include="DigitalData.Core.Abstractions, Version=4.3.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\DigitalData.Core.Abstractions.4.3.0\lib\net462\DigitalData.Core.Abstractions.dll</HintPath>
+    </Reference>
     <Reference Include="DigitalData.Modules.Base, Version=1.3.8.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\packages\DigitalData.Modules.Base.1.3.8\lib\net462\DigitalData.Modules.Base.dll</HintPath>
     </Reference>
@@ -100,9 +109,6 @@
     <Reference Include="EntityFramework.SqlServer, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL">
       <HintPath>..\packages\EntityFramework.6.5.1\lib\net45\EntityFramework.SqlServer.dll</HintPath>
     </Reference>
-    <Reference Include="EnvelopeGenerator.CommonServices">
-      <HintPath>..\EnvelopeGenerator.CommonServices\bin\Debug\EnvelopeGenerator.CommonServices.dll</HintPath>
-    </Reference>
     <Reference Include="FirebirdSql.Data.FirebirdClient, Version=7.5.0.0, Culture=neutral, PublicKeyToken=3750abcc3150b00c, processorArchitecture=MSIL">
       <HintPath>..\packages\FirebirdSql.Data.FirebirdClient.7.5.0\lib\net452\FirebirdSql.Data.FirebirdClient.dll</HintPath>
     </Reference>
@@ -176,12 +182,84 @@
     <Reference Include="Microsoft.Bcl.Cryptography, Version=9.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
       <HintPath>..\packages\Microsoft.Bcl.Cryptography.9.0.0\lib\net462\Microsoft.Bcl.Cryptography.dll</HintPath>
     </Reference>
+    <Reference Include="Microsoft.Bcl.HashCode, Version=1.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Bcl.HashCode.1.1.1\lib\net461\Microsoft.Bcl.HashCode.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Data.SqlClient, Version=1.13.20136.2, Culture=neutral, PublicKeyToken=23ec7fc2d6eaa4a5, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Data.SqlClient.1.1.3\lib\net46\Microsoft.Data.SqlClient.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.EntityFrameworkCore, Version=3.1.32.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.EntityFrameworkCore.3.1.32\lib\netstandard2.0\Microsoft.EntityFrameworkCore.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.EntityFrameworkCore.Abstractions, Version=3.1.32.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.EntityFrameworkCore.Abstractions.3.1.32\lib\netstandard2.0\Microsoft.EntityFrameworkCore.Abstractions.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.EntityFrameworkCore.Relational, Version=3.1.32.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.EntityFrameworkCore.Relational.3.1.32\lib\netstandard2.0\Microsoft.EntityFrameworkCore.Relational.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.EntityFrameworkCore.SqlServer, Version=3.1.32.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.EntityFrameworkCore.SqlServer.3.1.32\lib\netstandard2.0\Microsoft.EntityFrameworkCore.SqlServer.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.Caching.Abstractions, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.Caching.Abstractions.7.0.0\lib\net462\Microsoft.Extensions.Caching.Abstractions.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.Caching.Memory, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.Caching.Memory.7.0.0\lib\net462\Microsoft.Extensions.Caching.Memory.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.Configuration, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.Configuration.7.0.0\lib\net462\Microsoft.Extensions.Configuration.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.Configuration.Abstractions, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.Configuration.Abstractions.7.0.0\lib\net462\Microsoft.Extensions.Configuration.Abstractions.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.Configuration.Binder, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.Configuration.Binder.7.0.0\lib\net462\Microsoft.Extensions.Configuration.Binder.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.DependencyInjection, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.DependencyInjection.7.0.0\lib\net462\Microsoft.Extensions.DependencyInjection.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.DependencyInjection.Abstractions, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.DependencyInjection.Abstractions.7.0.0\lib\net462\Microsoft.Extensions.DependencyInjection.Abstractions.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.Localization.Abstractions, Version=7.0.16.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.Localization.Abstractions.7.0.16\lib\net462\Microsoft.Extensions.Localization.Abstractions.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.Logging, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.Logging.7.0.0\lib\net462\Microsoft.Extensions.Logging.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.Logging.Abstractions, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.Logging.Abstractions.7.0.0\lib\net462\Microsoft.Extensions.Logging.Abstractions.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.Options, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.Options.7.0.0\lib\net462\Microsoft.Extensions.Options.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.Options.ConfigurationExtensions, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.Options.ConfigurationExtensions.7.0.0\lib\net462\Microsoft.Extensions.Options.ConfigurationExtensions.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.Primitives, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.Primitives.7.0.0\lib\net462\Microsoft.Extensions.Primitives.dll</HintPath>
+    </Reference>
     <Reference Include="Microsoft.Identity.Client, Version=4.77.0.0, Culture=neutral, PublicKeyToken=0a613f4dd989e8ae, processorArchitecture=MSIL">
       <HintPath>..\packages\Microsoft.Identity.Client.4.77.0\lib\net462\Microsoft.Identity.Client.dll</HintPath>
     </Reference>
     <Reference Include="Microsoft.IdentityModel.Abstractions, Version=8.14.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
       <HintPath>..\packages\Microsoft.IdentityModel.Abstractions.8.14.0\lib\net462\Microsoft.IdentityModel.Abstractions.dll</HintPath>
     </Reference>
+    <Reference Include="Microsoft.IdentityModel.JsonWebTokens, Version=7.5.1.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.IdentityModel.JsonWebTokens.7.5.1\lib\net462\Microsoft.IdentityModel.JsonWebTokens.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.IdentityModel.Logging, Version=7.5.1.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.IdentityModel.Logging.7.5.1\lib\net462\Microsoft.IdentityModel.Logging.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.IdentityModel.Protocols, Version=5.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.IdentityModel.Protocols.5.5.0\lib\net461\Microsoft.IdentityModel.Protocols.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.IdentityModel.Protocols.OpenIdConnect, Version=5.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.IdentityModel.Protocols.OpenIdConnect.5.5.0\lib\net461\Microsoft.IdentityModel.Protocols.OpenIdConnect.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.IdentityModel.Tokens, Version=7.5.1.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.IdentityModel.Tokens.7.5.1\lib\net462\Microsoft.IdentityModel.Tokens.dll</HintPath>
+    </Reference>
     <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
       <HintPath>..\packages\Newtonsoft.Json.13.0.3\lib\net45\Newtonsoft.Json.dll</HintPath>
     </Reference>
@@ -216,19 +294,31 @@
     <Reference Include="System.Collections.Immutable, Version=9.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
       <HintPath>..\packages\System.Collections.Immutable.9.0.0\lib\net462\System.Collections.Immutable.dll</HintPath>
     </Reference>
+    <Reference Include="System.ComponentModel.Annotations, Version=4.2.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.ComponentModel.Annotations.4.7.0\lib\net461\System.ComponentModel.Annotations.dll</HintPath>
+    </Reference>
     <Reference Include="System.ComponentModel.DataAnnotations" />
     <Reference Include="System.Configuration" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Data.Common, Version=4.1.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.Data.Common.4.3.0\lib\net451\System.Data.Common.dll</HintPath>
+      <Private>True</Private>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="System.Data.Odbc, Version=6.0.0.1, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
       <HintPath>..\packages\System.Data.Odbc.6.0.1\lib\net461\System.Data.Odbc.dll</HintPath>
     </Reference>
-    <Reference Include="System.Diagnostics.DiagnosticSource, Version=6.0.0.1, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Diagnostics.DiagnosticSource.6.0.1\lib\net461\System.Diagnostics.DiagnosticSource.dll</HintPath>
+    <Reference Include="System.Diagnostics.DiagnosticSource, Version=7.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.Diagnostics.DiagnosticSource.7.0.0\lib\net462\System.Diagnostics.DiagnosticSource.dll</HintPath>
     </Reference>
+    <Reference Include="System.DirectoryServices.AccountManagement" />
     <Reference Include="System.Formats.Asn1, Version=9.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
       <HintPath>..\packages\System.Formats.Asn1.9.0.0\lib\net462\System.Formats.Asn1.dll</HintPath>
     </Reference>
     <Reference Include="System.IdentityModel" />
+    <Reference Include="System.IdentityModel.Tokens.Jwt, Version=7.5.1.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.IdentityModel.Tokens.Jwt.7.5.1\lib\net462\System.IdentityModel.Tokens.Jwt.dll</HintPath>
+    </Reference>
     <Reference Include="System.IO.Compression" />
     <Reference Include="System.IO.Packaging, Version=9.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
       <HintPath>..\packages\System.IO.Packaging.9.0.0\lib\net462\System.IO.Packaging.dll</HintPath>
@@ -252,9 +342,25 @@
       <HintPath>..\packages\System.Runtime.CompilerServices.Unsafe.6.1.0\lib\net462\System.Runtime.CompilerServices.Unsafe.dll</HintPath>
     </Reference>
     <Reference Include="System.Security" />
+    <Reference Include="System.Security.Cryptography.Algorithms, Version=4.1.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.Security.Cryptography.Algorithms.4.3.1\lib\net461\System.Security.Cryptography.Algorithms.dll</HintPath>
+      <Private>True</Private>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="System.Security.Cryptography.Cng, Version=5.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.Security.Cryptography.Cng.5.0.0\lib\net462\System.Security.Cryptography.Cng.dll</HintPath>
+    </Reference>
     <Reference Include="System.Security.Cryptography.Pkcs, Version=9.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
       <HintPath>..\packages\System.Security.Cryptography.Pkcs.9.0.0\lib\net462\System.Security.Cryptography.Pkcs.dll</HintPath>
     </Reference>
+    <Reference Include="System.Security.Cryptography.Primitives, Version=4.0.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.Security.Cryptography.Primitives.4.3.0\lib\net46\System.Security.Cryptography.Primitives.dll</HintPath>
+      <Private>True</Private>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="System.Security.Principal.Windows, Version=5.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.Security.Principal.Windows.5.0.0\lib\net461\System.Security.Principal.Windows.dll</HintPath>
+    </Reference>
     <Reference Include="System.Text.Encodings.Web, Version=9.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
       <HintPath>..\packages\System.Text.Encodings.Web.9.0.0\lib\net462\System.Text.Encodings.Web.dll</HintPath>
     </Reference>
@@ -357,10 +463,18 @@
       <Project>{6EA0C51F-C2B1-4462-8198-3DE0B32B74F8}</Project>
       <Name>EnvelopeGenerator.CommonServices</Name>
     </ProjectReference>
+    <ProjectReference Include="..\EnvelopeGenerator.CommonServices\EnvelopeGenerator.CommonServices.vbproj">
+      <Project>{6ea0c51f-c2b1-4462-8198-3de0b32b74f8}</Project>
+      <Name>EnvelopeGenerator.CommonServices</Name>
+    </ProjectReference>
     <ProjectReference Include="..\EnvelopeGenerator.Domain\EnvelopeGenerator.Domain.csproj">
-      <Project>{4F32A98D-E6F0-4A09-BD97-1CF26107E837}</Project>
+      <Project>{4f32a98d-e6f0-4a09-bd97-1cf26107e837}</Project>
       <Name>EnvelopeGenerator.Domain</Name>
     </ProjectReference>
+    <ProjectReference Include="..\EnvelopeGenerator.Infrastructure\EnvelopeGenerator.Infrastructure.csproj">
+      <Project>{63e32615-0eca-42dc-96e3-91037324b7c7}</Project>
+      <Name>EnvelopeGenerator.Infrastructure</Name>
+    </ProjectReference>
   </ItemGroup>
   <ItemGroup>
     <Content Include="GdPicture.NET.14.barcode.1d.reader.64.dll" />
@@ -382,6 +496,9 @@
     <Content Include="MailLicense.xml" />
     <Content Include="README.txt" />
   </ItemGroup>
+  <ItemGroup>
+    <WCFMetadata Include="Connected Services\" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.VisualBasic.targets" />
   <Import Project="..\packages\GdPicture.runtimes.windows.14.3.3\build\net462\GdPicture.runtimes.windows.targets" Condition="Exists('..\packages\GdPicture.runtimes.windows.14.3.3\build\net462\GdPicture.runtimes.windows.targets')" />
   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
@@ -391,8 +508,10 @@
     <Error Condition="!Exists('..\packages\GdPicture.runtimes.windows.14.3.3\build\net462\GdPicture.runtimes.windows.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\GdPicture.runtimes.windows.14.3.3\build\net462\GdPicture.runtimes.windows.targets'))" />
     <Error Condition="!Exists('..\packages\EntityFramework.6.5.1\build\EntityFramework.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\EntityFramework.6.5.1\build\EntityFramework.props'))" />
     <Error Condition="!Exists('..\packages\EntityFramework.6.5.1\build\EntityFramework.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\EntityFramework.6.5.1\build\EntityFramework.targets'))" />
+    <Error Condition="!Exists('..\packages\Microsoft.Data.SqlClient.SNI.1.1.0\build\net46\Microsoft.Data.SqlClient.SNI.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.Data.SqlClient.SNI.1.1.0\build\net46\Microsoft.Data.SqlClient.SNI.targets'))" />
   </Target>
   <Import Project="..\packages\EntityFramework.6.5.1\build\EntityFramework.targets" Condition="Exists('..\packages\EntityFramework.6.5.1\build\EntityFramework.targets')" />
+  <Import Project="..\packages\Microsoft.Data.SqlClient.SNI.1.1.0\build\net46\Microsoft.Data.SqlClient.SNI.targets" Condition="Exists('..\packages\Microsoft.Data.SqlClient.SNI.1.1.0\build\net46\Microsoft.Data.SqlClient.SNI.targets')" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">

EnvelopeGenerator.BBTests/app.config

@@ -107,6 +107,78 @@
         <assemblyIdentity name="GdPicture.NET.14.Imaging" publicKeyToken="f52a2e60ad468dbb" culture="neutral" />
         <bindingRedirect oldVersion="0.0.0.0-14.3.3.0" newVersion="14.3.3.0" />
       </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.Identity.Client" publicKeyToken="0a613f4dd989e8ae" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.77.0.0" newVersion="4.77.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Diagnostics.DiagnosticSource" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-7.0.0.0" newVersion="7.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.IdentityModel.Abstractions" publicKeyToken="31bf3856ad364e35" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-8.14.0.0" newVersion="8.14.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.Bcl.AsyncInterfaces" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-9.0.0.0" newVersion="9.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.Text.Encodings.Web" publicKeyToken="cc7b13ffcd2ddd51" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-9.0.0.0" newVersion="9.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.Extensions.DependencyInjection.Abstractions" publicKeyToken="adb9793829ddae60" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-7.0.0.0" newVersion="7.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.Extensions.Logging.Abstractions" publicKeyToken="adb9793829ddae60" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-7.0.0.0" newVersion="7.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.Extensions.Caching.Abstractions" publicKeyToken="adb9793829ddae60" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-7.0.0.0" newVersion="7.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.ComponentModel.Annotations" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-4.2.1.0" newVersion="4.2.1.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.Extensions.DependencyInjection" publicKeyToken="adb9793829ddae60" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-7.0.0.0" newVersion="7.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.Extensions.Logging" publicKeyToken="adb9793829ddae60" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-7.0.0.0" newVersion="7.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.Extensions.Caching.Memory" publicKeyToken="adb9793829ddae60" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-7.0.0.0" newVersion="7.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.Extensions.Options" publicKeyToken="adb9793829ddae60" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-7.0.0.0" newVersion="7.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.Extensions.Configuration.Abstractions" publicKeyToken="adb9793829ddae60" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-7.0.0.0" newVersion="7.0.0.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.IdentityModel.Logging" publicKeyToken="31bf3856ad364e35" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-7.5.1.0" newVersion="7.5.1.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.IdentityModel.Tokens" publicKeyToken="31bf3856ad364e35" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-7.5.1.0" newVersion="7.5.1.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="System.IdentityModel.Tokens.Jwt" publicKeyToken="31bf3856ad364e35" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-7.5.1.0" newVersion="7.5.1.0" />
+      </dependentAssembly>
+      <dependentAssembly>
+        <assemblyIdentity name="Microsoft.IdentityModel.JsonWebTokens" publicKeyToken="31bf3856ad364e35" culture="neutral" />
+        <bindingRedirect oldVersion="0.0.0.0-7.5.1.0" newVersion="7.5.1.0" />
+      </dependentAssembly>
     </assemblyBinding>
   </runtime>
   <entityFramework>

EnvelopeGenerator.BBTests/frmFinalizePDF.vb

@@ -1,10 +1,14 @@
-Imports DigitalData.Modules.Database
+Imports System.IO
+Imports DigitalData.Modules.Database
 Imports DigitalData.Modules.Logging
+Imports EnvelopeGenerator.CommonServices.Jobs
+Imports EnvelopeGenerator.CommonServices.Jobs.FinalizeDocument
 Imports GdPicture14
 Imports Newtonsoft.Json.Linq
-Imports EnvelopeGenerator.CommonServices.Jobs
-Imports System.IO
-Imports EnvelopeGenerator.CommonServices.Jobs.FinalizeDocument
+Imports EnvelopeGenerator.Infrastructure
+Imports Microsoft.EntityFrameworkCore
+Imports System.Text
+Imports DigitalData.Core.Abstractions
 
 Public Class frmFinalizePDF
     Private Const CONNECTIONSTRING = "Server=sDD-VMP04-SQL17\DD_DEVELOP01;Database=DD_ECM;User Id=sa;Password=+bk8oAbbQP1AzoHtvZUbd+Mbok2f8Fl4miEx1qssJ5yEaEWoQJ9prg4L14fURpPnqi1WMNs9fE4=;"
@@ -20,10 +24,35 @@ Public Class frmFinalizePDF
 
     Private Sub frmFinalizePDF_Load(sender As Object, e As EventArgs) Handles MyBase.Load
         LogConfig = New LogConfig(LogConfig.PathType.CustomPath, Application.StartupPath)
-        Database = New MSSQLServer(LogConfig, MSSQLServer.DecryptConnectionString(CONNECTIONSTRING))
 
+        Dim dCnnStr As String = MSSQLServer.DecryptConnectionString(CONNECTIONSTRING)
 
-        PDFBurner = New FinalizeDocument.PDFBurner(LogConfig, pGDPictureLicenseKey, _pdfBurnerParams)
+        Database = New MSSQLServer(LogConfig, dCnnStr)
+
+#Disable Warning BC40000 ' Type or member is obsolete
+        Factory.Shared _
+            .BehaveOnPostBuild(PostBuildBehavior.Ignore) _
+            .AddEnvelopeGeneratorInfrastructureServices(
+                Sub(opt)
+                    opt.AddDbTriggerParams(
+                        Sub(triggers)
+                            triggers("Envelope") = New List(Of String) From {"TBSIG_ENVELOPE_AFT_INS"}
+                            triggers("History") = New List(Of String) From {"TBSIG_ENVELOPE_HISTORY_AFT_INS"}
+                            triggers("EmailOut") = New List(Of String) From {"TBEMLP_EMAIL_OUT_AFT_INS", "TBEMLP_EMAIL_OUT_AFT_UPD"}
+                            triggers("EnvelopeReceiverReadOnly") = New List(Of String) From {"TBSIG_ENVELOPE_RECEIVER_READ_ONLY_UPD"}
+                            triggers("Receiver") = New List(Of String)() ' no tigger
+                            triggers("EmailTemplate") = New List(Of String) From {"TBSIG_EMAIL_TEMPLATE_AFT_UPD"}
+                        End Sub)
+                    opt.AddDbContext(
+                        Sub(options)
+                            options.UseSqlServer(dCnnStr) _
+                                   .EnableSensitiveDataLogging() _
+                                   .EnableDetailedErrors()
+                        End Sub)
+                End Sub)
+#Enable Warning BC40000 ' Type or member is obsolete
+
+        PDFBurner = New PDFBurner(LogConfig, pGDPictureLicenseKey, _pdfBurnerParams)
 
         Viewer = New GdViewer()
         Manager = New AnnotationManager()
@@ -72,8 +101,9 @@ Public Class frmFinalizePDF
                 Select(Function(r As DataRow) r.Item("VALUE").ToString()).
                 ToList()
 
-            Dim oBuffer As Byte() = ReadEnvelope(CInt(txtEnvelope.Text))
-            Dim oNewBuffer = PDFBurner.BurnInstantJSONAnnotationsToPDF(oBuffer, oJsonList)
+            Dim envelopeId As Integer = CInt(txtEnvelope.Text)
+            Dim oBuffer As Byte() = ReadEnvelope(envelopeId)
+            Dim oNewBuffer = PDFBurner.BurnAnnotsToPDF(oBuffer, oJsonList, envelopeId)
             Dim desktopPath As String = Environment.GetFolderPath(Environment.SpecialFolder.Desktop)
             Dim oNewPath = Path.Combine(desktopPath, $"E{txtEnvelope.Text}R{txtReceiver.Text}.burned.pdf")
 
@@ -81,7 +111,15 @@ Public Class frmFinalizePDF
 
             Process.Start(oNewPath)
         Catch ex As Exception
-            MsgBox(ex.Message, MsgBoxStyle.Critical)
+            Dim exMsg As StringBuilder = New StringBuilder(ex.Message).AppendLine()
+
+            Dim innerEx = ex.InnerException
+            While (innerEx IsNot Nothing)
+                exMsg.AppendLine(innerEx.Message)
+                innerEx = innerEx.InnerException
+            End While
+
+            MsgBox(exMsg.ToString(), MsgBoxStyle.Critical)
         End Try
 
     End Sub

EnvelopeGenerator.BBTests/packages.config

@@ -1,7 +1,10 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
+  <package id="AutoMapper" version="10.1.1" targetFramework="net462" />
   <package id="BouncyCastle.Cryptography" version="2.5.0" targetFramework="net462" />
   <package id="DigitalData.Controls.DocumentViewer" version="1.9.8" targetFramework="net462" />
+  <package id="DigitalData.Core.Abstraction.Application" version="1.6.0" targetFramework="net462" />
+  <package id="DigitalData.Core.Abstractions" version="4.3.0" targetFramework="net462" />
   <package id="DigitalData.Modules.Base" version="1.3.8" targetFramework="net462" />
   <package id="DigitalData.Modules.Config" version="1.3.0" targetFramework="net462" />
   <package id="DigitalData.Modules.Database" version="2.3.5.4" targetFramework="net462" />
@@ -18,9 +21,35 @@
   <package id="Microsoft.AspNet.WebApi.Client" version="6.0.0" targetFramework="net462" />
   <package id="Microsoft.Bcl.AsyncInterfaces" version="9.0.0" targetFramework="net462" />
   <package id="Microsoft.Bcl.Cryptography" version="9.0.0" targetFramework="net462" />
+  <package id="Microsoft.Bcl.HashCode" version="1.1.1" targetFramework="net462" />
   <package id="Microsoft.CSharp" version="4.7.0" targetFramework="net462" />
+  <package id="Microsoft.Data.SqlClient" version="1.1.3" targetFramework="net462" />
+  <package id="Microsoft.Data.SqlClient.SNI" version="1.1.0" targetFramework="net462" />
+  <package id="Microsoft.EntityFrameworkCore" version="3.1.32" targetFramework="net462" />
+  <package id="Microsoft.EntityFrameworkCore.Abstractions" version="3.1.32" targetFramework="net462" />
+  <package id="Microsoft.EntityFrameworkCore.Analyzers" version="3.1.32" targetFramework="net462" />
+  <package id="Microsoft.EntityFrameworkCore.Relational" version="3.1.32" targetFramework="net462" />
+  <package id="Microsoft.EntityFrameworkCore.SqlServer" version="3.1.32" targetFramework="net462" />
+  <package id="Microsoft.Extensions.Caching.Abstractions" version="7.0.0" targetFramework="net462" />
+  <package id="Microsoft.Extensions.Caching.Memory" version="7.0.0" targetFramework="net462" />
+  <package id="Microsoft.Extensions.Configuration" version="7.0.0" targetFramework="net462" />
+  <package id="Microsoft.Extensions.Configuration.Abstractions" version="7.0.0" targetFramework="net462" />
+  <package id="Microsoft.Extensions.Configuration.Binder" version="7.0.0" targetFramework="net462" />
+  <package id="Microsoft.Extensions.DependencyInjection" version="7.0.0" targetFramework="net462" />
+  <package id="Microsoft.Extensions.DependencyInjection.Abstractions" version="7.0.0" targetFramework="net462" />
+  <package id="Microsoft.Extensions.Localization.Abstractions" version="7.0.16" targetFramework="net462" />
+  <package id="Microsoft.Extensions.Logging" version="7.0.0" targetFramework="net462" />
+  <package id="Microsoft.Extensions.Logging.Abstractions" version="7.0.0" targetFramework="net462" />
+  <package id="Microsoft.Extensions.Options" version="7.0.0" targetFramework="net462" />
+  <package id="Microsoft.Extensions.Options.ConfigurationExtensions" version="7.0.0" targetFramework="net462" />
+  <package id="Microsoft.Extensions.Primitives" version="7.0.0" targetFramework="net462" />
   <package id="Microsoft.Identity.Client" version="4.77.0" targetFramework="net462" />
   <package id="Microsoft.IdentityModel.Abstractions" version="8.14.0" targetFramework="net462" />
+  <package id="Microsoft.IdentityModel.JsonWebTokens" version="7.5.1" targetFramework="net462" />
+  <package id="Microsoft.IdentityModel.Logging" version="7.5.1" targetFramework="net462" />
+  <package id="Microsoft.IdentityModel.Protocols" version="5.5.0" targetFramework="net462" />
+  <package id="Microsoft.IdentityModel.Protocols.OpenIdConnect" version="5.5.0" targetFramework="net462" />
+  <package id="Microsoft.IdentityModel.Tokens" version="7.5.1" targetFramework="net462" />
   <package id="Microsoft.VisualBasic" version="10.3.0" targetFramework="net462" />
   <package id="Newtonsoft.Json" version="13.0.3" targetFramework="net462" />
   <package id="Newtonsoft.Json.Bson" version="1.0.2" targetFramework="net462" />
@@ -33,15 +62,24 @@
   <package id="System.Buffers" version="4.6.0" targetFramework="net462" />
   <package id="System.CodeDom" version="9.0.0" targetFramework="net462" />
   <package id="System.Collections.Immutable" version="9.0.0" targetFramework="net462" />
+  <package id="System.ComponentModel.Annotations" version="4.7.0" targetFramework="net462" />
+  <package id="System.Data.Common" version="4.3.0" targetFramework="net462" />
   <package id="System.Data.Odbc" version="6.0.1" targetFramework="net462" />
+  <package id="System.Diagnostics.DiagnosticSource" version="7.0.0" targetFramework="net462" />
+  <package id="System.DirectoryServices.AccountManagement" version="7.0.1" targetFramework="net462" />
   <package id="System.Formats.Asn1" version="9.0.0" targetFramework="net462" />
+  <package id="System.IdentityModel.Tokens.Jwt" version="7.5.1" targetFramework="net462" />
   <package id="System.IO.Packaging" version="9.0.0" targetFramework="net462" />
   <package id="System.IO.Pipelines" version="9.0.0" targetFramework="net462" />
   <package id="System.Management" version="9.0.0" targetFramework="net462" />
   <package id="System.Memory" version="4.6.0" targetFramework="net462" />
   <package id="System.Numerics.Vectors" version="4.6.0" targetFramework="net462" />
   <package id="System.Runtime.CompilerServices.Unsafe" version="6.1.0" targetFramework="net462" />
+  <package id="System.Security.Cryptography.Algorithms" version="4.3.1" targetFramework="net462" />
+  <package id="System.Security.Cryptography.Cng" version="5.0.0" targetFramework="net462" />
   <package id="System.Security.Cryptography.Pkcs" version="9.0.0" targetFramework="net462" />
+  <package id="System.Security.Cryptography.Primitives" version="4.3.0" targetFramework="net462" />
+  <package id="System.Security.Principal.Windows" version="5.0.0" targetFramework="net462" />
   <package id="System.Text.Encodings.Web" version="9.0.0" targetFramework="net462" />
   <package id="System.Text.Json" version="9.0.0" targetFramework="net462" />
   <package id="System.Threading.Tasks.Extensions" version="4.5.4" targetFramework="net462" />

EnvelopeGenerator.CommonServices/EnvelopeGenerator.CommonServices.vbproj

@@ -48,6 +48,9 @@
     <OptionInfer>On</OptionInfer>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="AutoMapper, Version=10.0.0.0, Culture=neutral, PublicKeyToken=be96cd2c38ef1005, processorArchitecture=MSIL">
+      <HintPath>..\packages\AutoMapper.10.1.1\lib\net461\AutoMapper.dll</HintPath>
+    </Reference>
     <Reference Include="BouncyCastle.Cryptography, Version=2.0.0.0, Culture=neutral, PublicKeyToken=072edcf4a5328938, processorArchitecture=MSIL">
       <HintPath>..\packages\BouncyCastle.Cryptography.2.5.0\lib\net461\BouncyCastle.Cryptography.dll</HintPath>
     </Reference>
@@ -69,6 +72,13 @@
     <Reference Include="DevExpress.XtraEditors.v21.2, Version=21.2.4.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a" />
     <Reference Include="DevExpress.XtraGauges.v21.2.Core, Version=21.2.4.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a, processorArchitecture=MSIL" />
     <Reference Include="DevExpress.XtraReports.v21.2, Version=21.2.4.0, Culture=neutral, PublicKeyToken=b88d1754d700e49a, processorArchitecture=MSIL" />
+    <Reference Include="DigitalData.Core.Abstraction.Application, Version=1.6.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\DigitalData.Core.Abstraction.Application.1.6.0\lib\net462\DigitalData.Core.Abstraction.Application.dll</HintPath>
+    </Reference>
+    <Reference Include="DigitalData.Core.Abstractions, Version=4.3.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\DigitalData.Core.Abstractions.4.3.0\lib\net462\DigitalData.Core.Abstractions.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="DigitalData.Modules.Base, Version=1.3.8.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\packages\DigitalData.Modules.Base.1.3.8\lib\net462\DigitalData.Modules.Base.dll</HintPath>
     </Reference>
@@ -172,9 +182,84 @@
     <Reference Include="Microsoft.Bcl.AsyncInterfaces, Version=8.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
       <HintPath>..\packages\Microsoft.Bcl.AsyncInterfaces.8.0.0\lib\net462\Microsoft.Bcl.AsyncInterfaces.dll</HintPath>
     </Reference>
+    <Reference Include="Microsoft.Bcl.HashCode, Version=1.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Bcl.HashCode.1.1.1\lib\net461\Microsoft.Bcl.HashCode.dll</HintPath>
+    </Reference>
     <Reference Include="Microsoft.CSharp" />
-    <Reference Include="Microsoft.Extensions.Logging.Abstractions, Version=2.1.1.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
-      <HintPath>..\packages\Microsoft.Extensions.Logging.Abstractions.2.1.1\lib\netstandard2.0\Microsoft.Extensions.Logging.Abstractions.dll</HintPath>
+    <Reference Include="Microsoft.Data.SqlClient, Version=1.13.20136.2, Culture=neutral, PublicKeyToken=23ec7fc2d6eaa4a5, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Data.SqlClient.1.1.3\lib\net46\Microsoft.Data.SqlClient.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.EntityFrameworkCore, Version=3.1.32.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.EntityFrameworkCore.3.1.32\lib\netstandard2.0\Microsoft.EntityFrameworkCore.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.EntityFrameworkCore.Abstractions, Version=3.1.32.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.EntityFrameworkCore.Abstractions.3.1.32\lib\netstandard2.0\Microsoft.EntityFrameworkCore.Abstractions.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.EntityFrameworkCore.Relational, Version=3.1.32.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.EntityFrameworkCore.Relational.3.1.32\lib\netstandard2.0\Microsoft.EntityFrameworkCore.Relational.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.EntityFrameworkCore.SqlServer, Version=3.1.32.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.EntityFrameworkCore.SqlServer.3.1.32\lib\netstandard2.0\Microsoft.EntityFrameworkCore.SqlServer.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.Caching.Abstractions, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.Caching.Abstractions.7.0.0\lib\net462\Microsoft.Extensions.Caching.Abstractions.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.Caching.Memory, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.Caching.Memory.7.0.0\lib\net462\Microsoft.Extensions.Caching.Memory.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.Configuration, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.Configuration.7.0.0\lib\net462\Microsoft.Extensions.Configuration.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.Configuration.Abstractions, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.Configuration.Abstractions.7.0.0\lib\net462\Microsoft.Extensions.Configuration.Abstractions.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.Configuration.Binder, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.Configuration.Binder.7.0.0\lib\net462\Microsoft.Extensions.Configuration.Binder.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.DependencyInjection, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.DependencyInjection.7.0.0\lib\net462\Microsoft.Extensions.DependencyInjection.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.DependencyInjection.Abstractions, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.DependencyInjection.Abstractions.7.0.0\lib\net462\Microsoft.Extensions.DependencyInjection.Abstractions.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.Localization.Abstractions, Version=7.0.16.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.Localization.Abstractions.7.0.16\lib\net462\Microsoft.Extensions.Localization.Abstractions.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.Logging, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.Logging.7.0.0\lib\net462\Microsoft.Extensions.Logging.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.Logging.Abstractions, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.Logging.Abstractions.7.0.0\lib\net462\Microsoft.Extensions.Logging.Abstractions.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.Options, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.Options.7.0.0\lib\net462\Microsoft.Extensions.Options.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.Options.ConfigurationExtensions, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.Options.ConfigurationExtensions.7.0.0\lib\net462\Microsoft.Extensions.Options.ConfigurationExtensions.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Extensions.Primitives, Version=7.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Extensions.Primitives.7.0.0\lib\net462\Microsoft.Extensions.Primitives.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.Identity.Client, Version=3.0.8.0, Culture=neutral, PublicKeyToken=0a613f4dd989e8ae, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.Identity.Client.3.0.8\lib\net45\Microsoft.Identity.Client.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.IdentityModel.Abstractions, Version=7.5.1.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.IdentityModel.Abstractions.7.5.1\lib\net462\Microsoft.IdentityModel.Abstractions.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.IdentityModel.JsonWebTokens, Version=7.5.1.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.IdentityModel.JsonWebTokens.7.5.1\lib\net462\Microsoft.IdentityModel.JsonWebTokens.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.IdentityModel.Logging, Version=7.5.1.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.IdentityModel.Logging.7.5.1\lib\net462\Microsoft.IdentityModel.Logging.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.IdentityModel.Protocols, Version=5.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.IdentityModel.Protocols.5.5.0\lib\net461\Microsoft.IdentityModel.Protocols.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.IdentityModel.Protocols.OpenIdConnect, Version=5.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.IdentityModel.Protocols.OpenIdConnect.5.5.0\lib\net461\Microsoft.IdentityModel.Protocols.OpenIdConnect.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.IdentityModel.Tokens, Version=7.5.1.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\Microsoft.IdentityModel.Tokens.7.5.1\lib\net462\Microsoft.IdentityModel.Tokens.dll</HintPath>
     </Reference>
     <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
       <HintPath>..\packages\Newtonsoft.Json.13.0.3\lib\net45\Newtonsoft.Json.dll</HintPath>
@@ -216,13 +301,26 @@
     <Reference Include="System.ComponentModel.DataAnnotations" />
     <Reference Include="System.Configuration" />
     <Reference Include="System.Data" />
+    <Reference Include="System.Data.Common, Version=4.1.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.Data.Common.4.3.0\lib\net451\System.Data.Common.dll</HintPath>
+      <Private>True</Private>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="System.Data.Odbc, Version=6.0.0.1, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
       <HintPath>..\packages\System.Data.Odbc.6.0.1\lib\net461\System.Data.Odbc.dll</HintPath>
     </Reference>
+    <Reference Include="System.Diagnostics.DiagnosticSource, Version=7.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.Diagnostics.DiagnosticSource.7.0.0\lib\net462\System.Diagnostics.DiagnosticSource.dll</HintPath>
+    </Reference>
+    <Reference Include="System.DirectoryServices.AccountManagement" />
     <Reference Include="System.Drawing" />
     <Reference Include="System.Drawing.Common, Version=4.0.0.2, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
       <HintPath>..\packages\System.Drawing.Common.4.7.3\lib\net461\System.Drawing.Common.dll</HintPath>
     </Reference>
+    <Reference Include="System.IdentityModel" />
+    <Reference Include="System.IdentityModel.Tokens.Jwt, Version=7.5.1.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.IdentityModel.Tokens.Jwt.7.5.1\lib\net462\System.IdentityModel.Tokens.Jwt.dll</HintPath>
+    </Reference>
     <Reference Include="System.IO.Compression" />
     <Reference Include="System.IO.Packaging, Version=8.0.0.1, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
       <HintPath>..\packages\System.IO.Packaging.8.0.1\lib\net462\System.IO.Packaging.dll</HintPath>
@@ -244,9 +342,25 @@
     <Reference Include="System.Runtime.Remoting" />
     <Reference Include="System.Runtime.Serialization" />
     <Reference Include="System.Security" />
+    <Reference Include="System.Security.Cryptography.Algorithms, Version=4.1.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.Security.Cryptography.Algorithms.4.3.1\lib\net461\System.Security.Cryptography.Algorithms.dll</HintPath>
+      <Private>True</Private>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="System.Security.Cryptography.Cng, Version=5.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.Security.Cryptography.Cng.5.0.0\lib\net462\System.Security.Cryptography.Cng.dll</HintPath>
+    </Reference>
     <Reference Include="System.Security.Cryptography.Pkcs, Version=8.0.0.1, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
       <HintPath>..\packages\System.Security.Cryptography.Pkcs.8.0.1\lib\net462\System.Security.Cryptography.Pkcs.dll</HintPath>
     </Reference>
+    <Reference Include="System.Security.Cryptography.Primitives, Version=4.0.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.Security.Cryptography.Primitives.4.3.0\lib\net46\System.Security.Cryptography.Primitives.dll</HintPath>
+      <Private>True</Private>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="System.Security.Principal.Windows, Version=5.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <HintPath>..\packages\System.Security.Principal.Windows.5.0.0\lib\net461\System.Security.Principal.Windows.dll</HintPath>
+    </Reference>
     <Reference Include="System.ServiceModel" />
     <Reference Include="System.Text.Encodings.Web, Version=8.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
       <HintPath>..\packages\System.Text.Encodings.Web.8.0.0\lib\net462\System.Text.Encodings.Web.dll</HintPath>
@@ -446,6 +560,14 @@
       <Project>{4f32a98d-e6f0-4a09-bd97-1cf26107e837}</Project>
       <Name>EnvelopeGenerator.Domain</Name>
     </ProjectReference>
+    <ProjectReference Include="..\EnvelopeGenerator.Infrastructure\EnvelopeGenerator.Infrastructure.csproj">
+      <Project>{63e32615-0eca-42dc-96e3-91037324b7c7}</Project>
+      <Name>EnvelopeGenerator.Infrastructure</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\EnvelopeGenerator.PdfEditor\EnvelopeGenerator.PdfEditor.csproj">
+      <Project>{211619f5-ae25-4ba5-a552-bacafe0632d3}</Project>
+      <Name>EnvelopeGenerator.PdfEditor</Name>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.VisualBasic.targets" />
   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
@@ -455,7 +577,9 @@
     <Error Condition="!Exists('..\packages\EntityFramework.6.4.4\build\EntityFramework.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\EntityFramework.6.4.4\build\EntityFramework.props'))" />
     <Error Condition="!Exists('..\packages\EntityFramework.6.4.4\build\EntityFramework.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\EntityFramework.6.4.4\build\EntityFramework.targets'))" />
     <Error Condition="!Exists('..\packages\GdPicture.runtimes.windows.14.3.3\build\net462\GdPicture.runtimes.windows.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\GdPicture.runtimes.windows.14.3.3\build\net462\GdPicture.runtimes.windows.targets'))" />
+    <Error Condition="!Exists('..\packages\Microsoft.Data.SqlClient.SNI.1.1.0\build\net46\Microsoft.Data.SqlClient.SNI.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.Data.SqlClient.SNI.1.1.0\build\net46\Microsoft.Data.SqlClient.SNI.targets'))" />
   </Target>
   <Import Project="..\packages\EntityFramework.6.4.4\build\EntityFramework.targets" Condition="Exists('..\packages\EntityFramework.6.4.4\build\EntityFramework.targets')" />
   <Import Project="..\packages\GdPicture.runtimes.windows.14.3.3\build\net462\GdPicture.runtimes.windows.targets" Condition="Exists('..\packages\GdPicture.runtimes.windows.14.3.3\build\net462\GdPicture.runtimes.windows.targets')" />
+  <Import Project="..\packages\Microsoft.Data.SqlClient.SNI.1.1.0\build\net46\Microsoft.Data.SqlClient.SNI.targets" Condition="Exists('..\packages\Microsoft.Data.SqlClient.SNI.1.1.0\build\net46\Microsoft.Data.SqlClient.SNI.targets')" />
 </Project>

EnvelopeGenerator.CommonServices/Jobs/FinalizeDocument/FinalizeDocumentJob.vb

@@ -11,6 +11,10 @@ Imports EnvelopeGenerator.Domain.Constants
 Imports DevExpress.DataProcessing
 Imports System.Data.SqlClient
 Imports EnvelopeGenerator.Domain.Entities
+Imports DigitalData.Core.Abstraction.Application
+Imports EnvelopeGenerator.Infrastructure
+Imports Microsoft.EntityFrameworkCore
+Imports DigitalData.Core.Abstractions
 
 Namespace Jobs
     Public Class FinalizeDocumentJob
@@ -62,7 +66,31 @@ Namespace Jobs
                 LicenseManager.RegisterKEY(oGdPictureKey)
 
                 Logger.Debug("Loading Database..")
-                Database = GetDatabase(pContext, LogConfig)
+                Dim oConnectionString As String = pContext.MergedJobDataMap.Item(Value.DATABASE)
+                Database = New MSSQLServer(LogConfig, MSSQLServer.DecryptConnectionString(oConnectionString))
+
+#Disable Warning BC40000 ' Type or member is obsolete
+                Factory.Shared _
+                .BehaveOnPostBuild(PostBuildBehavior.Ignore) _
+                .AddEnvelopeGeneratorInfrastructureServices(
+                Sub(opt)
+                    opt.AddDbTriggerParams(
+                        Sub(triggers)
+                            triggers("Envelope") = New List(Of String) From {"TBSIG_ENVELOPE_AFT_INS"}
+                            triggers("History") = New List(Of String) From {"TBSIG_ENVELOPE_HISTORY_AFT_INS"}
+                            triggers("EmailOut") = New List(Of String) From {"TBEMLP_EMAIL_OUT_AFT_INS", "TBEMLP_EMAIL_OUT_AFT_UPD"}
+                            triggers("EnvelopeReceiverReadOnly") = New List(Of String) From {"TBSIG_ENVELOPE_RECEIVER_READ_ONLY_UPD"}
+                            triggers("Receiver") = New List(Of String)() ' no tigger
+                            triggers("EmailTemplate") = New List(Of String) From {"TBSIG_EMAIL_TEMPLATE_AFT_UPD"}
+                        End Sub)
+                    opt.AddDbContext(
+                        Sub(options)
+                            options.UseSqlServer(oConnectionString) _
+                                   .EnableSensitiveDataLogging() _
+                                   .EnableDetailedErrors()
+                        End Sub)
+                End Sub)
+#Enable Warning BC40000 ' Type or member is obsolete
 
                 Logger.Debug("Loading Models & Services")
                 Dim oState = GetState()
@@ -378,7 +406,6 @@ Namespace Jobs
                 ParentFolderUID = pEnvelopeData.EnvelopeUUID
             End If
 
-
             Logger.Info("ParentFolderUID: [{0}]", ParentFolderUID)
             Dim oInputDocumentBuffer As Byte()
             If Not IsNothing(pEnvelopeData.DocAsByte) Then
@@ -391,11 +418,11 @@ Namespace Jobs
                 End Try
             End If
 
-            Return PDFBurner.BurnInstantJSONAnnotationsToPDF(oInputDocumentBuffer, oAnnotations)
+            Return PDFBurner.BurnAnnotsToPDF(oInputDocumentBuffer, oAnnotations, pEnvelopeData.EnvelopeId)
         End Function
 
         Private Function GetEnvelopeData(pEnvelopeId As Integer) As EnvelopeData
-            Dim oSql = $"SELECT T.GUID, T.ENVELOPE_UUID,T2.FILEPATH, T2.BYTE_DATA FROM [dbo].[TBSIG_ENVELOPE] T
+            Dim oSql = $"SELECT T.GUID, T.ENVELOPE_UUID, T.ENVELOPE_TYPE, T2.FILEPATH, T2.BYTE_DATA FROM [dbo].[TBSIG_ENVELOPE] T
                 JOIN TBSIG_ENVELOPE_DOCUMENT T2 ON T.GUID = T2.ENVELOPE_ID
                 WHERE T.GUID = {pEnvelopeId}"
             Dim oTable As DataTable = Database.GetDatatable(oSql)
@@ -439,13 +466,6 @@ Namespace Jobs
             ReportModel = New ReportModel(pState)
         End Sub
 
-        Private Function GetDatabase(pContext As IJobExecutionContext, pLogConfig As LogConfig) As MSSQLServer
-            Dim oConnectionString As String = pContext.MergedJobDataMap.Item(Value.DATABASE)
-            Dim Database = New MSSQLServer(pLogConfig, MSSQLServer.DecryptConnectionString(oConnectionString))
-
-            Return Database
-        End Function
-
         Private Function GetState() As State
             Return New State With {
                 .LogConfig = LogConfig,