MS Anpassungen

Handling InsertReceivers und kleinigkeiten frm Main
Logging wegen Y-Konstante
2025-11-12 21:43:50 +01:00 · 2025-09-16 09:00:43 +02:00 · 2025-09-04 14:35:54 +02:00
580 changed files with 14310 additions and 17643 deletions
--- a/EnvelopeGenerator.API/Controllers/AnnotationController.cs
+++ b/EnvelopeGenerator.API/Controllers/AnnotationController.cs
@@ -1,118 +0,0 @@
 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(Roles = Role.Receiver.FullyAuth)]
 [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(Roles = Role.Receiver.FullyAuth)]
    [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(Roles = Role.Receiver.FullyAuth)]
    [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);
    }
 }
--- a/EnvelopeGenerator.API/Controllers/AuthController.cs
+++ b/EnvelopeGenerator.API/Controllers/AuthController.cs
@@ -1,59 +0,0 @@
 using Microsoft.AspNetCore.Authentication.Cookies;
 using Microsoft.AspNetCore.Authentication;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Authorization;
 using EnvelopeGenerator.API.Models;
 namespace EnvelopeGenerator.API.Controllers;
 /// <summary>
 /// Controller verantwortlich für die Benutzer-Authentifizierung, einschließlich Anmelden, Abmelden und Überprüfung des Authentifizierungsstatus.
 /// </summary>
 /// <param name="logger"></param>
 [Route("api/[controller]")]
 [ApiController]
 public partial class AuthController(ILogger<AuthController> logger) : ControllerBase
 {
    /// <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(string), StatusCodes.Status200OK, "text/javascript")]
    [ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
    [Authorize]
    [HttpPost("logout")]
    public async Task<IActionResult> Logout()
    {
        await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
        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(string), StatusCodes.Status200OK, "text/javascript")]
    [ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
    [Authorize]
    [HttpGet]
    public IActionResult IsAuthenticated() => Ok();
 }
--- a/EnvelopeGenerator.API/Controllers/ConfigController.cs
+++ b/EnvelopeGenerator.API/Controllers/ConfigController.cs
@@ -1,30 +0,0 @@
 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);
    }
 }
--- a/EnvelopeGenerator.API/Controllers/DocumentController.cs
+++ b/EnvelopeGenerator.API/Controllers/DocumentController.cs
@@ -1,57 +0,0 @@
 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, ILogger<DocumentController> logger) : ControllerBase
 {
    /// <summary>
    /// Returns the document bytes receiver.
    /// </summary>
    /// <param name="query">Encoded envelope key.</param>
    /// <param name="cancel">Cancellation token.</param>
    [HttpGet]
    [Authorize(Roles = $"{Role.Sender},{Role.Receiver.FullyAuth}")]
    public async Task<IActionResult> GetDocument(CancellationToken cancel, [FromQuery] ReadDocumentQuery? query = null)
    {
        // Sender: expects query with envelope key
        if (User.IsInRole(Role.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 (User.IsInRole(Role.Receiver.FullyAuth))
        {           
            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();
    }
 }
--- a/EnvelopeGenerator.API/Controllers/EnvelopeController.cs
+++ b/EnvelopeGenerator.API/Controllers/EnvelopeController.cs
@@ -1,111 +0,0 @@
 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);
    }
 }
--- a/EnvelopeGenerator.API/Controllers/EnvelopeTypeController.cs
+++ b/EnvelopeGenerator.API/Controllers/EnvelopeTypeController.cs
@@ -1,39 +0,0 @@
 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);
    }
 }
--- a/EnvelopeGenerator.API/Controllers/ReadOnlyController.cs
+++ b/EnvelopeGenerator.API/Controllers/ReadOnlyController.cs
@@ -1,90 +0,0 @@
 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(Roles = Role.Receiver.FullyAuth)]
    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);
        });
    }
 }
--- a/EnvelopeGenerator.API/Controllers/ReceiverController.cs
+++ b/EnvelopeGenerator.API/Controllers/ReceiverController.cs
@@ -1,47 +0,0 @@
 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);
    }
 }
--- a/EnvelopeGenerator.API/Controllers/TfaRegistrationController.cs
+++ b/EnvelopeGenerator.API/Controllers/TfaRegistrationController.cs
@@ -1,129 +0,0 @@
 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(Roles = Role.FullyAuth)]
    [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() });
        }
    }
 }
--- a/EnvelopeGenerator.API/Documentation/AuthProxyDocumentFilter.cs
+++ b/EnvelopeGenerator.API/Documentation/AuthProxyDocumentFilter.cs
@@ -1,70 +0,0 @@
 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
            }
        };
    }
 }
--- a/EnvelopeGenerator.API/EnvelopeClaimTypes.cs
+++ b/EnvelopeGenerator.API/EnvelopeClaimTypes.cs
@@ -1,17 +0,0 @@
 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)}";
 }
--- a/EnvelopeGenerator.API/Extensions/ReceiverClaimExtensions.cs
+++ b/EnvelopeGenerator.API/Extensions/ReceiverClaimExtensions.cs
@@ -1,101 +0,0 @@
 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);
    }
 }
--- a/EnvelopeGenerator.API/Extensions/SenderClaimExtensions.cs
+++ b/EnvelopeGenerator.API/Extensions/SenderClaimExtensions.cs
@@ -1,95 +0,0 @@
 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);
    }
 }
--- a/EnvelopeGenerator.API/Models/Auth.cs
+++ b/EnvelopeGenerator.API/Models/Auth.cs
@@ -1,14 +0,0 @@
 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);
 }
--- a/EnvelopeGenerator.API/Models/ContactLink.cs
+++ b/EnvelopeGenerator.API/Models/ContactLink.cs
@@ -1,60 +0,0 @@
 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;
    }
 }
--- a/EnvelopeGenerator.API/Models/Culture.cs
+++ b/EnvelopeGenerator.API/Models/Culture.cs
@@ -1,17 +0,0 @@
 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; }
 }
--- a/EnvelopeGenerator.API/Models/Cultures.cs
+++ b/EnvelopeGenerator.API/Models/Cultures.cs
@@ -1,12 +0,0 @@
 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();
 }
--- a/EnvelopeGenerator.API/Models/CustomImages.cs
+++ b/EnvelopeGenerator.API/Models/CustomImages.cs
@@ -1,6 +0,0 @@
 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();
 }
--- a/EnvelopeGenerator.API/Models/ErrorViewModel.cs
+++ b/EnvelopeGenerator.API/Models/ErrorViewModel.cs
@@ -1,10 +0,0 @@
 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";
 }
--- a/EnvelopeGenerator.API/Models/Image.cs
+++ b/EnvelopeGenerator.API/Models/Image.cs
@@ -1,10 +0,0 @@
 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;
 }
--- a/EnvelopeGenerator.API/Models/MainViewModel.cs
+++ b/EnvelopeGenerator.API/Models/MainViewModel.cs
@@ -1,6 +0,0 @@
 namespace EnvelopeGenerator.API.Models;
 public class MainViewModel
 {
    public string? Title { get; init; }
 }
--- a/EnvelopeGenerator.API/Models/PsPdfKitAnnotation/Annotation.cs
+++ b/EnvelopeGenerator.API/Models/PsPdfKitAnnotation/Annotation.cs
@@ -1,93 +0,0 @@
 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;
        }
    }
 };
--- a/EnvelopeGenerator.API/Models/PsPdfKitAnnotation/AnnotationParams.cs
+++ b/EnvelopeGenerator.API/Models/PsPdfKitAnnotation/AnnotationParams.cs
@@ -1,80 +0,0 @@
 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
 }
--- a/EnvelopeGenerator.API/Models/PsPdfKitAnnotation/Background.cs
+++ b/EnvelopeGenerator.API/Models/PsPdfKitAnnotation/Background.cs
@@ -1,58 +0,0 @@
 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;
    }
 }
--- a/EnvelopeGenerator.API/Models/PsPdfKitAnnotation/Color.cs
+++ b/EnvelopeGenerator.API/Models/PsPdfKitAnnotation/Color.cs
@@ -1,10 +0,0 @@
 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;
 }
--- a/EnvelopeGenerator.API/Models/PsPdfKitAnnotation/Extensions.cs
+++ b/EnvelopeGenerator.API/Models/PsPdfKitAnnotation/Extensions.cs
@@ -1,8 +0,0 @@
 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;
 }
--- a/EnvelopeGenerator.API/Models/PsPdfKitAnnotation/IAnnotation.cs
+++ b/EnvelopeGenerator.API/Models/PsPdfKitAnnotation/IAnnotation.cs
@@ -1,22 +0,0 @@
 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; }
 }
--- a/EnvelopeGenerator.API/Models/TFARegParams.cs
+++ b/EnvelopeGenerator.API/Models/TFARegParams.cs
@@ -1,17 +0,0 @@
 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);
 }
--- a/EnvelopeGenerator.API/yarp.json
+++ b/EnvelopeGenerator.API/yarp.json
@@ -1,25 +0,0 @@
 {
  "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"
          }
        }
      }
    }
  }
 }
--- a/EnvelopeGenerator.Application/Common/Dto/AnnotationDto.cs
+++ b/EnvelopeGenerator.Application/Common/Dto/AnnotationDto.cs
@@ -1,73 +0,0 @@
 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; }
 }
--- a/EnvelopeGenerator.Application/Common/EnvelopeFlag.cs
+++ b/EnvelopeGenerator.Application/Common/EnvelopeFlag.cs
@@ -1,27 +0,0 @@
 namespace EnvelopeGenerator.Application.Common;
 /// <summary>
 /// 
 /// </summary>
 public enum EnvelopeFlag
 {
    /// <summary>
    /// 
    /// </summary>
    EnvelopeOrReceiverNonexists,
    /// <summary>
    /// 
    /// </summary>
    NonDecodableEnvelopeReceiverId,
    /// <summary>
    /// 
    /// </summary>
    WrongEnvelopeReceiverId,
    /// <summary>
    /// 
    /// </summary>
    AccessCodeNull
 }
--- a/EnvelopeGenerator.Application/Common/Extensions/DecodingExtensions.cs
+++ b/EnvelopeGenerator.Application/Common/Extensions/DecodingExtensions.cs
@@ -1,182 +0,0 @@
 using EnvelopeGenerator.Domain.Constants;
 using System.Text;
 namespace EnvelopeGenerator.Application.Common.Extensions;
 /// <summary>
 /// 
 /// </summary>
 public static class DecodingExtensions
 {
    /// <summary>
    /// Validates whether a given string is a correctly formatted Base-64 encoded string.
    /// </summary>
    /// <remarks>
    /// This method checks the string for proper Base-64 formatting, which includes validating
    /// the length of the string (must be divisible by 4). It also checks each character to ensure
    /// it belongs to the Base-64 character set (A-Z, a-z, 0-9, '+', '/', and '=' for padding).
    /// The method ensures that padding characters ('=') only appear at the end of the string and
    /// are in a valid configuration (either one '=' at the end if the string's length % 4 is 3,
    /// or two '==' if the length % 4 is 2).
    /// </remarks>
    /// <param name="input">The Base-64 encoded string to validate.</param>
    /// <returns>
    /// <c>true</c> if the string is a valid Base-64 encoded string; otherwise, <c>false</c>.
    /// </returns>
    /// <example>
    /// <code>
    /// string testString = "TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnk=";
    /// bool isValid = IsValidBase64String(testString);
    /// Console.WriteLine(isValid); // Output: true
    /// </code>
    /// </example>
    public static bool IsBase64String(this string input)
    {
        // Check if the string is null or empty
        if (string.IsNullOrEmpty(input))
        {
            return false;
        }
        // Replace valid base-64 padding
        input = input.Trim();
        int mod4 = input.Length % 4;
        if (mod4 > 0)
        {
            // Base-64 string lengths should be divisible by 4
            return false;
        }
        // Check each character to ensure it is valid base-64
        foreach (char c in input)
        {
            if (!char.IsLetterOrDigit(c) && c != '+' && c != '/' && c != '=')
            {
                // Invalid character detected
                return false;
            }
        }
        // Ensure no invalid padding scenarios exist
        if (input.EndsWith("==") && input.Length % 4 == 0 ||
            input.EndsWith("=") && input.Length % 4 == 3)
        {
            return true;
        }
        return input.IndexOf('=') == -1; // No padding allowed except at the end
    }
    /// <summary>
    /// 
    /// </summary>
    /// <param name="encodedKey"></param>
    /// <param name="decodedKeys"></param>
    /// <returns></returns>
    public static bool TryDecode(this string encodedKey, out string[] decodedKeys)
    {
        try
        {
            byte[] bytes = Convert.FromBase64String(encodedKey);
            string decodedString = Encoding.UTF8.GetString(bytes);
            decodedKeys = decodedString.Split(new string[] { "::" }, StringSplitOptions.None);
            return true;
        }
        catch(ArgumentNullException) { }
        catch (FormatException) { }
        catch(ArgumentException) { }
        decodedKeys = Array.Empty<string>();
        return false;
    }
    /// <summary>
    /// 
    /// </summary>
    /// <param name="decodedKeys"></param>
    /// <returns></returns>
    public static EncodeType GetEncodeType(this string[] decodedKeys) => decodedKeys.Length switch
    {
        2 => EncodeType.EnvelopeReceiver,
        3 => long.TryParse(decodedKeys[1], out var _) ? EncodeType.EnvelopeReceiverReadOnly : EncodeType.Undefined,
        _ => EncodeType.Undefined,
    };
    /// <summary>
    /// 
    /// </summary>
    /// <param name="decodedKeys"></param>
    /// <returns></returns>
    /// <exception cref="InvalidOperationException"></exception>
    public static (string? EnvelopeUuid, string? ReceiverSignature) ParseEnvelopeReceiverId(this string[] decodedKeys)
        => decodedKeys.GetEncodeType() == EncodeType.EnvelopeReceiver
        ? (EnvelopeUuid: decodedKeys[0], ReceiverSignature: decodedKeys[1])
        : throw new InvalidOperationException("Attempted to convert a decoded other than type EnvelopeReceiver to EnvelopeReceiver.");
    /// <summary>
    /// 
    /// </summary>
    /// <param name="decodedKeys"></param>
    /// <returns></returns>
    /// <exception cref="InvalidOperationException"></exception>
    public static long ParseReadOnlyId(this string[] decodedKeys)
        => decodedKeys.GetEncodeType() == EncodeType.EnvelopeReceiverReadOnly
        ? long.Parse(decodedKeys[1])
        : throw new InvalidOperationException("Attempted to convert a decoded other than type EnvelopeReceiver to EnvelopeReceiver. ");
    /// <summary>
    /// Decodes the envelope receiver ID and extracts the envelope UUID and receiver signature.
    /// </summary>
    /// <param name="envelopeReceiverId">The base64 encoded string containing the envelope UUID and receiver signature.</param>
    /// <returns>A tuple containing the envelope UUID and receiver signature.</returns>
    public static (string? EnvelopeUuid, string? ReceiverSignature) DecodeEnvelopeReceiverId(this string envelopeReceiverId)
    {
        if (!envelopeReceiverId.IsBase64String())
        {
            return (null, null);
        }
        byte[] bytes = Convert.FromBase64String(envelopeReceiverId);
        string decodedString = Encoding.UTF8.GetString(bytes);
        string[] parts = decodedString.Split(new string[] { "::" }, StringSplitOptions.None);
        if (parts.Length > 1)
            return (EnvelopeUuid: parts[0], ReceiverSignature: parts[1]);
        else
            return (string.Empty, string.Empty);
    }
    /// <summary>
    /// 
    /// </summary>
    /// <param name="envelopeReceiverReadOnlyId"></param>
    /// <returns></returns>
    public static long? DecodeEnvelopeReceiverReadOnlyId(this string envelopeReceiverReadOnlyId)
    {
        if (!envelopeReceiverReadOnlyId.IsBase64String())
        {
            return null;
        }
        byte[] bytes = Convert.FromBase64String(envelopeReceiverReadOnlyId);
        string decodedString = Encoding.UTF8.GetString(bytes);
        string[] parts = decodedString.Split(new string[] { "::" }, StringSplitOptions.None);
        if (parts.Length > 2)
            return long.TryParse(parts[1], out long readOnlyId) ? readOnlyId : null;
        else
            return null;
    }
    /// <summary>
    /// Gets the envelope UUID from the decoded envelope receiver ID.
    /// </summary>
    /// <param name="envelopeReceiverId">The base64 encoded string to decode.</param>
    /// <returns>The envelope UUID.</returns>
    public static string? GetEnvelopeUuid(this string envelopeReceiverId) => envelopeReceiverId.DecodeEnvelopeReceiverId().EnvelopeUuid;
    /// <summary>
    /// Gets the receiver signature from the decoded envelope receiver ID.
    /// </summary>
    /// <param name="envelopeReceiverId">The base64 encoded string to decode.</param>
    /// <returns>The receiver signature.</returns>
    public static string? GetReceiverSignature(this string envelopeReceiverId) => envelopeReceiverId.DecodeEnvelopeReceiverId().ReceiverSignature;
 }
--- a/EnvelopeGenerator.Application/Common/Extensions/EncodingExtensions.cs
+++ b/EnvelopeGenerator.Application/Common/Extensions/EncodingExtensions.cs
@@ -1,38 +0,0 @@
 using System.Text;
 namespace EnvelopeGenerator.Application.Common.Extensions;
 /// <summary>
 /// Provides extension methods for decoding and extracting information from an envelope receiver ID.
 /// </summary>
 public static class EncodingExtensions
 {
    /// <summary>
    /// 
    /// </summary>
    /// <param name="readOnlyId"></param>
    /// <returns></returns>
    public static string ToEnvelopeKey(this long readOnlyId)
    {
        //The random number is used as a salt to increase security but it is not saved in the database.
        string combinedString = $"{Random.Shared.Next()}::{readOnlyId}::{Random.Shared.Next()}";
        byte[] bytes = Encoding.UTF8.GetBytes(combinedString);
        string base64String = Convert.ToBase64String(bytes);
        return base64String;
    }
    /// <summary>
    /// 
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public static string ToEnvelopeKey(this (string envelopeUuid, string receiverSignature) input)
    {
        string combinedString = $"{input.envelopeUuid}::{input.receiverSignature}";
        byte[] bytes = Encoding.UTF8.GetBytes(combinedString);
        string base64String = Convert.ToBase64String(bytes);
        return base64String;
    }
 }
--- a/EnvelopeGenerator.Application/Common/Extensions/JsonExtensions.cs
+++ b/EnvelopeGenerator.Application/Common/Extensions/JsonExtensions.cs
@@ -1,18 +0,0 @@
 using System.Text.Json;
 namespace EnvelopeGenerator.Application.Common.Extensions;
 /// <summary>
 /// 
 /// </summary>
 public static class JsonExtensions
 {
    /// <summary>
    /// 
    /// </summary>
    /// <param name="obj"></param>
    /// <param name="options"></param>
    /// <returns></returns>
    public static string ToJson(this object obj, JsonSerializerOptions? options = null)
        => JsonSerializer.Serialize(obj, options);
 }
--- a/EnvelopeGenerator.Application/Common/Extensions/QueryExtensions.cs
+++ b/EnvelopeGenerator.Application/Common/Extensions/QueryExtensions.cs
@@ -1,125 +0,0 @@
 using DigitalData.Core.Exceptions;
 using EnvelopeGenerator.Application.Common.Extensions;
 using EnvelopeGenerator.Application.Common.Query;
 using EnvelopeGenerator.Domain.Entities;
 using EnvelopeGenerator.Domain.Interfaces;
 namespace EnvelopeGenerator.Application.Common.Extensions;
 /// <summary>
 /// 
 /// </summary>
 public static class QueryExtensions
 {
    /// <summary>
    /// 
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    /// <param name="root"></param>
    /// <param name="query"></param>
    /// <param name="notnull"></param>
    /// <returns></returns>
    /// <exception cref="BadRequestException"></exception>
    public static IQueryable<TEntity> Where<TEntity>(this IQueryable<TEntity> root, EnvelopeQueryBase query, bool notnull = true)
        where TEntity : IHasEnvelope
    {
        if (query.Id is not null)
            root = root.Where(e => e.Envelope!.Id == query.Id);
        else if (query.Uuid is not null)
            root = root.Where(e => e.Envelope!.Uuid == query.Uuid);
        else if (notnull)
            throw new BadRequestException(
                "Either Envelope Id or Envelope Uuid must be provided in the query."
            );
        return root;
    }
    /// <summary>
    /// 
    /// </summary>
    /// <param name="root"></param>
    /// <param name="query"></param>
    /// <param name="notnull"></param>
    /// <returns></returns>
    /// <exception cref="BadRequestException"></exception>
    public static IQueryable<Envelope> Where(this IQueryable<Envelope> root, EnvelopeQueryBase query, bool notnull = true)
    {
        if (query.Id is not null)
            root = root.Where(e => e.Id == query.Id);
        else if (query.Uuid is not null)
            root = root.Where(e => e.Uuid == query.Uuid);
        else if (notnull)
            throw new BadRequestException(
                "Either Envelope Id or Envelope Uuid must be provided in the query."
            );
        return root;
    }
    /// <summary>
    /// 
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    /// <param name="root"></param>
    /// <param name="query"></param>
    /// <param name="notnull"></param>
    /// <returns></returns>
    /// <exception cref="BadRequestException"></exception>
    public static IQueryable<TEntity> Where<TEntity>(this IQueryable<TEntity> root, ReceiverQueryBase query, bool notnull = true)
        where TEntity : IHasReceiver
    {
        if (query.Id is not null)
            root = root.Where(e => e.Receiver!.Id == query.Id);
        else if (query.EmailAddress is not null)
            root = root.Where(e => e.Receiver!.EmailAddress == query.EmailAddress);
        else if (query.Signature is not null)
            root = root.Where(e => e.Receiver!.Signature == query.Signature);
        else if (notnull)
            throw new BadRequestException(
                "Receiver must have at least one identifier (Id, EmailAddress, or Signature)."
            );
        return root;
    }
    /// <summary>
    /// 
    /// </summary>
    /// <param name="root"></param>
    /// <param name="query"></param>
    /// <param name="notnull"></param>
    /// <returns></returns>
    /// <exception cref="BadRequestException"></exception>
    public static IQueryable<Receiver> Where(this IQueryable<Receiver> root, ReceiverQueryBase query, bool notnull = true)
    {
        if (query.Id is not null)
            root = root.Where(e => e.Id == query.Id);
        else if (query.EmailAddress is not null)
            root = root.Where(e => e.EmailAddress == query.EmailAddress);
        else if (query.Signature is not null)
            root = root.Where(e => e.Signature == query.Signature);
        else if (notnull)
            throw new BadRequestException(
                "Receiver must have at least one identifier (Id, EmailAddress, or Signature)."
            );
        return root;
    }
    /// <summary>
    /// 
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    /// <typeparam name="TEnvelopeQuery"></typeparam>
    /// <typeparam name="TReceiverQuery"></typeparam>
    /// <param name="root"></param>
    /// <param name="query"></param>
    /// <param name="notnull"></param>
    /// <returns></returns>
    public static IQueryable<TEntity> Where<TEntity, TEnvelopeQuery, TReceiverQuery>(this IQueryable<TEntity> root, EnvelopeReceiverQueryBase<TEnvelopeQuery, TReceiverQuery> query, bool notnull = true)
        where TEntity : IHasEnvelope, IHasReceiver
        where TEnvelopeQuery : EnvelopeQueryBase, new()
        where TReceiverQuery : ReceiverQueryBase, new() 
        => root.Where(query.Envelope, notnull).Where(query.Receiver, notnull);
 }
--- a/EnvelopeGenerator.Application/Common/Extensions/StringExtension.cs
+++ b/EnvelopeGenerator.Application/Common/Extensions/StringExtension.cs
@@ -1,30 +0,0 @@
 using OtpNet;
 namespace EnvelopeGenerator.Application.Common.Extensions;
 /// <summary>
 /// 
 /// </summary>
 public static class StringExtension
 {
    /// <summary>
    /// 
    /// </summary>
    /// <param name="totp"></param>
    /// <param name="secret"></param>
    /// <returns></returns>
    public static bool IsValidTotp(this string totp, string secret)
    {
        var secret_bytes = Base32Encoding.ToBytes(secret);
        var secret_totp = new Totp(secret_bytes);
        return secret_totp.VerifyTotp(totp, out _, VerificationWindow.RfcSpecifiedNetworkDelay);
    }
    /// <summary>
    /// 
    /// </summary>
    /// <param name="seperator"></param>
    /// <param name="values"></param>
    /// <returns></returns>
    public static string Join(this IEnumerable<string> values, string seperator) => string.Join(seperator, values);
 }
--- a/EnvelopeGenerator.Application/Common/Extensions/TaskExtensions.cs
+++ b/EnvelopeGenerator.Application/Common/Extensions/TaskExtensions.cs
@@ -1,105 +0,0 @@
 using DigitalData.Core.Exceptions;
 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>
    /// Awaits the specified task and ensures that the result is not <c>null</c>.
    /// If the result is <c>null</c>, the exception created by factory-method is thrown.
    /// </summary>
    /// <typeparam name="T">The type of the result.</typeparam>
    /// <typeparam name="TException">The type of the exception.</typeparam>
    /// <param name="task">The task to await.</param>
    /// <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;
        return result ?? throw factory();
    }
    /// <summary>
    /// Awaits the specified task and ensures that the result is not <c>empty</c>.
    /// If the result contains no elements, the exception created by factory-method is thrown.
    /// </summary>
    /// <typeparam name="T">The element type of the collection.</typeparam>
    /// <typeparam name="TException">The type of the exception.</typeparam>
    /// <param name="task">The task to await.</param>
    /// <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;
        return result?.Any() ?? false ? result : throw factory();
    }
    /// <summary>
    /// 
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="I"></typeparam>
    /// <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>
 /// 
 /// </summary>
 public static class Exceptions
 {
    /// <summary>
    /// 
    /// </summary>
    public static NotFoundException NotFound() => new();
    /// <summary>
    /// 
    /// </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();
 }
--- a/EnvelopeGenerator.Application/Common/Extensions/XSSExtensions.cs
+++ b/EnvelopeGenerator.Application/Common/Extensions/XSSExtensions.cs
@@ -1,43 +0,0 @@
 using Ganss.Xss;
 using Microsoft.Extensions.Localization;
 using System.Text.Encodings.Web;
 namespace EnvelopeGenerator.Application.Common.Extensions;
 /// <summary>
 /// 
 /// </summary>
 public static class XSSExtensions
 {
    /// <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);
    /// <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);
    /// <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);
    /// <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);
 }
--- a/EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeDocumentService.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeDocumentService.cs
@@ -1,13 +0,0 @@
 using DigitalData.Core.Abstraction.Application;
 using EnvelopeGenerator.Application.Common.Dto;
 using EnvelopeGenerator.Domain.Entities;
 namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
 /// <summary>
 /// 
 /// </summary>
 [Obsolete("Use MediatR")]
 public interface IEnvelopeDocumentService : IBasicCRUDService<DocumentDto, Document, int>
 {
 }
--- a/EnvelopeGenerator.Application/Common/Notifications/DocSigned/DocSignedNotification.cs
+++ b/EnvelopeGenerator.Application/Common/Notifications/DocSigned/DocSignedNotification.cs
@@ -1,88 +0,0 @@
 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 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>
 /// <param name="Original"></param>
 public record DocSignedNotification(EnvelopeReceiverDto Original) : EnvelopeReceiverDto(Original), INotification, ISendMailNotification
 {
    /// <summary>
    /// 
    /// </summary>
    public PsPdfKitAnnotation? PsPdfKitAnnotation { get; init; }
    /// <summary>
    /// 
    /// </summary>
    public EmailTemplateType TemplateType => EmailTemplateType.DocumentSigned;
    /// <summary>
    /// 
    /// </summary>
    public string EmailAddress => Receiver?.EmailAddress
        ?? throw new InvalidOperationException($"Receiver is null." +
            $"DocSignedNotification:\n{this.ToJson(Format.Json.ForDiagnostics)}");
 }
 /// <summary>
 /// 
 /// </summary>
 public static class DocSignedNotificationExtensions
 {
    /// <summary>
    /// Converts an <see cref="EnvelopeReceiverDto"/> to a <see cref="DocSignedNotification"/>.
    /// </summary>
    /// <param name="dto">The DTO to convert.</param>
    /// <param name="psPdfKitAnnotation"></param>
    /// <returns>A new <see cref="DocSignedNotification"/> instance.</returns>
    public static DocSignedNotification ToDocSignedNotification(this EnvelopeReceiverDto dto, PsPdfKitAnnotation psPdfKitAnnotation)
        => new(dto) { PsPdfKitAnnotation = psPdfKitAnnotation };
    /// <summary>
    /// 
    /// </summary>
    /// <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;
        }
    }
 }
--- a/EnvelopeGenerator.Application/Common/Notifications/DocSigned/Handlers/AnnotationHandler.cs
+++ b/EnvelopeGenerator.Application/Common/Notifications/DocSigned/Handlers/AnnotationHandler.cs
@@ -1,37 +0,0 @@
 using DigitalData.Core.Abstraction.Application.Repository;
 using EnvelopeGenerator.Domain.Entities;
 using MediatR;
 namespace EnvelopeGenerator.Application.Common.Notifications.DocSigned.Handlers;
 /// <summary>
 /// 
 /// </summary>
 public class AnnotationHandler : INotificationHandler<DocSignedNotification>
 {
    /// <summary>
    /// 
    /// </summary>
    private readonly IRepository<ElementAnnotation> _repo;
    /// <summary>
    /// 
    /// </summary>
    /// <param name="repository"></param>
    public AnnotationHandler(IRepository<ElementAnnotation> repository)
    {
        _repo = repository;
    }
    /// <summary>
    /// 
    /// </summary>
    /// <param name="notification"></param>
    /// <param name="cancel"></param>
    /// <returns></returns>
    public async Task Handle(DocSignedNotification notification, CancellationToken cancel)
    {
        if (notification.PsPdfKitAnnotation is PsPdfKitAnnotation annot)
            await _repo.CreateAsync(annot.Structured, cancel);
    }
 }
--- a/EnvelopeGenerator.Application/Common/Notifications/DocSigned/Handlers/DocStatusHandler.cs
+++ b/EnvelopeGenerator.Application/Common/Notifications/DocSigned/Handlers/DocStatusHandler.cs
@@ -1,43 +0,0 @@
 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);
    }
 }
--- a/EnvelopeGenerator.Application/Common/Notifications/DocSigned/Handlers/HistoryHandler.cs
+++ b/EnvelopeGenerator.Application/Common/Notifications/DocSigned/Handlers/HistoryHandler.cs
@@ -1,42 +0,0 @@
 using EnvelopeGenerator.Application.Common.Extensions;
 using EnvelopeGenerator.Application.Histories.Commands;
 using EnvelopeGenerator.Domain.Constants;
 using MediatR;
 namespace EnvelopeGenerator.Application.Common.Notifications.DocSigned.Handlers;
 /// <summary>
 /// 
 /// </summary>
 public class HistoryHandler : INotificationHandler<DocSignedNotification>
 {
    private readonly ISender _sender;
    /// <summary>
    /// 
    /// </summary>
    /// <param name="sender"></param>
    public HistoryHandler(ISender sender)
    {
        _sender = sender;
    }
    /// <summary>
    /// 
    /// </summary>
    /// <param name="notification"></param>
    /// <param name="cancel"></param>
    /// <returns></returns>
    public async Task Handle(DocSignedNotification notification, CancellationToken cancel)
    {
        if (notification.Receiver is null)
            throw new InvalidOperationException($"Receiver information is missing in the notification. DocSignedNotification:\n {notification.ToJson(Format.Json.ForDiagnostics)}");
        await _sender.Send(new CreateHistoryCommand()
        {
            EnvelopeId = notification.EnvelopeId,
            UserReference = notification.Receiver.EmailAddress,
            Status = EnvelopeStatus.DocumentSigned,
        }, cancel);
    }
 }
--- a/EnvelopeGenerator.Application/Common/Notifications/DocSigned/Handlers/SendSignedMailHandler.cs
+++ b/EnvelopeGenerator.Application/Common/Notifications/DocSigned/Handlers/SendSignedMailHandler.cs
@@ -1,50 +0,0 @@
 using DigitalData.Core.Abstraction.Application.Repository;
 using DigitalData.EmailProfilerDispatcher.Abstraction.Entities;
 using EnvelopeGenerator.Application.Common.Configurations;
 using EnvelopeGenerator.Domain.Entities;
 using Microsoft.Extensions.Options;
 namespace EnvelopeGenerator.Application.Common.Notifications.DocSigned.Handlers;
 /// <summary>
 /// 
 /// </summary>
 public class SendSignedMailHandler : SendMailHandler<DocSignedNotification>
 {
    /// <summary>
    /// 
    /// </summary>
    /// <param name="tempRepo"></param>
    /// <param name="emailOutRepo"></param>
    /// <param name="mailParamsOptions"></param>
    /// <param name="dispatcherParamsOptions"></param>
    public SendSignedMailHandler(IRepository<EmailTemplate> tempRepo, IRepository<EmailOut> emailOutRepo, IOptions<MailParams> mailParamsOptions, IOptions<DispatcherParams> dispatcherParamsOptions) : base(tempRepo, emailOutRepo, mailParamsOptions, dispatcherParamsOptions)
    {
    }
    /// <summary>
    /// 
    /// </summary>
    /// <param name="notification"></param>
    /// <param name="emailOut"></param>
    protected override void ConfigureEmailOut(DocSignedNotification notification, EmailOut emailOut)
    {
        emailOut.ReferenceString = notification.EmailAddress;
        emailOut.ReferenceId = notification.ReceiverId;
    }
    /// <summary>
    /// </summary>
    /// <param name="notification"></param>
    /// <returns></returns>
    protected override Dictionary<string, string> CreatePlaceHolders(DocSignedNotification notification)
    {
        var placeHolders = new Dictionary<string, string>()
        {
            { "[NAME_RECEIVER]", notification.Name ?? string.Empty },
            { "[DOCUMENT_TITLE]", notification.Envelope?.Title ?? string.Empty },
        };
        return placeHolders;
    }
 }
--- a/EnvelopeGenerator.Application/Common/Notifications/RemoveSignature/Handlers/RemoveAnnotationHandler.cs
+++ b/EnvelopeGenerator.Application/Common/Notifications/RemoveSignature/Handlers/RemoveAnnotationHandler.cs
@@ -1,53 +0,0 @@
 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);
    }
 }
--- a/EnvelopeGenerator.Application/Common/Notifications/RemoveSignature/Handlers/RemoveDocStatusHandler.cs
+++ b/EnvelopeGenerator.Application/Common/Notifications/RemoveSignature/Handlers/RemoveDocStatusHandler.cs
@@ -1,53 +0,0 @@
 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);
    }
 }
--- a/EnvelopeGenerator.Application/Common/Notifications/RemoveSignature/Handlers/RemoveHistoryHandler.cs
+++ b/EnvelopeGenerator.Application/Common/Notifications/RemoveSignature/Handlers/RemoveHistoryHandler.cs
@@ -1,56 +0,0 @@
 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);
    }
 }
--- a/EnvelopeGenerator.Application/Common/Notifications/RemoveSignature/RemoveSignatureNotification.cs
+++ b/EnvelopeGenerator.Application/Common/Notifications/RemoveSignature/RemoveSignatureNotification.cs
@@ -1,37 +0,0 @@
 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.");
    }
 }
--- a/EnvelopeGenerator.Application/Common/Notifications/SendMailHandler.cs
+++ b/EnvelopeGenerator.Application/Common/Notifications/SendMailHandler.cs
@@ -1,135 +0,0 @@
 using DigitalData.Core.Abstraction.Application.Repository;
 using DigitalData.EmailProfilerDispatcher.Abstraction.Entities;
 using EnvelopeGenerator.Application.Common.Configurations;
 using EnvelopeGenerator.Application.Common.Extensions;
 using EnvelopeGenerator.Domain.Constants;
 using EnvelopeGenerator.Domain.Entities;
 using MediatR;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Options;
 using Newtonsoft.Json;
 namespace EnvelopeGenerator.Application.Common.Notifications;
 /// <summary>
 /// 
 /// </summary>
 public interface ISendMailNotification : INotification
 {
    /// <summary>
    /// 
    /// </summary>
    public EmailTemplateType TemplateType { get; }
    /// <summary>
    /// 
    /// </summary>
    public string EmailAddress { get; }
 }
 /// <summary>
 /// 
 /// </summary>
 public abstract class SendMailHandler<TNotification> : INotificationHandler<TNotification>
    where TNotification : ISendMailNotification
 {
    /// <summary>
    /// 
    /// </summary>
    protected readonly IRepository<EmailTemplate> TempRepo;
    /// <summary>
    /// 
    /// </summary>
    protected readonly IRepository<EmailOut> EmailOutRepo;
    /// <summary>
    /// 
    /// </summary>
    protected abstract Dictionary<string, string> CreatePlaceHolders(TNotification notification);
    /// <summary>
    ///{ "[MESSAGE]", notification.Message },<br/>
    ///{ "[DOCUMENT_ACCESS_CODE]", notification.ReceiverAccessCode },<br/>
    ///{ "[REASON]", pReason }<br/>
    ///{ "[NAME_SENDER]", notification.Envelope.User?.FullName},<br/>
    ///{ "[NAME_PORTAL]", DispatcherParams. },<br/>
    ///{ "[SIGNATURE_TYPE]", "signieren" },<br/>
    ///{ "[LINK_TO_DOCUMENT]", notification.SignatureLink },<br/>
    ///{ "[LINK_TO_DOCUMENT_TEXT]", $"{notification.SignatureLink.Truncate(40)}.." },
    /// </summary>
    protected readonly MailParams MailParams;
    /// <summary>
    /// 
    /// </summary>
    protected readonly DispatcherParams DispatcherParams;
    /// <summary>
    /// 
    /// </summary>
    /// <param name="notification"></param>
    /// <param name="emailOut"></param>
    protected abstract void ConfigureEmailOut(TNotification notification, EmailOut emailOut);
    /// <summary>
    /// 
    /// </summary>
    /// <param name="tempRepo"></param>
    /// <param name="emailOutRepo"></param>
    /// <param name="mailParamsOptions"></param>
    /// <param name="dispatcherParamsOptions"></param>
    protected SendMailHandler(IRepository<EmailTemplate> tempRepo, IRepository<EmailOut> emailOutRepo, IOptions<MailParams> mailParamsOptions, IOptions<DispatcherParams> dispatcherParamsOptions)
    {
        TempRepo = tempRepo;
        EmailOutRepo = emailOutRepo;
        MailParams = mailParamsOptions.Value;
        DispatcherParams = dispatcherParamsOptions.Value;
    }
    /// <summary>
    /// 
    /// </summary>
    /// <param name="notification"></param>
    /// <param name="cancel"></param>
    /// <returns></returns>
    /// <exception cref="NotImplementedException"></exception>
    public virtual async Task Handle(TNotification notification, CancellationToken cancel)
    {
        var placeHolders = CreatePlaceHolders(notification);
        var temp = await TempRepo
            .Where(x => x.Name == notification.TemplateType.ToString())
            .SingleOrDefaultAsync(cancel)
                ?? throw new InvalidOperationException($"Receiver information is missing in the notification." +
                $"{typeof(TNotification)}:\n {notification.ToJson(Format.Json.ForDiagnostics)}");
        temp.Subject = ReplacePlaceHolders(temp.Subject, placeHolders, MailParams.Placeholders);
        temp.Body = ReplacePlaceHolders(temp.Body, placeHolders, MailParams.Placeholders);
        var emailOut = new EmailOut
        {
            EmailAddress = notification.EmailAddress,
            EmailBody = temp.Body,
            EmailSubj = temp.Subject,
            AddedWhen = DateTime.UtcNow,
            AddedWho = DispatcherParams.AddedWho,
            SendingProfile = DispatcherParams.SendingProfile,
            ReminderTypeId = DispatcherParams.ReminderTypeId,
            EmailAttmt1 = DispatcherParams.EmailAttmt1,
            WfId = (int)EnvelopeStatus.MessageConfirmationSent,
        };
        ConfigureEmailOut(notification, emailOut);
        await EmailOutRepo.CreateAsync(emailOut, cancel);
    }
    private static string ReplacePlaceHolders(string text, params Dictionary<string, string>[] placeHoldersList)
    {
        foreach (var placeHolders in placeHoldersList)
            foreach (var ph in placeHolders)
                text = text.Replace(ph.Key, ph.Value);
        return text;
    }
 }
--- a/EnvelopeGenerator.Application/Common/Query/EnvelopeQueryBase.cs
+++ b/EnvelopeGenerator.Application/Common/Query/EnvelopeQueryBase.cs
@@ -1,17 +0,0 @@
 namespace EnvelopeGenerator.Application.Common.Query;
 /// <summary>
 /// Repräsentiert eine Abfrage für Umschläge.
 /// </summary>
 public record EnvelopeQueryBase
 {
    /// <summary>
    /// Die eindeutige Kennung des Umschlags.
    /// </summary>
    public virtual int? Id { get; set; }
    /// <summary>
    /// Die universell eindeutige Kennung des Umschlags.
    /// </summary>
    public virtual string? Uuid { get; set; }
 }
--- a/EnvelopeGenerator.Application/Common/Query/EnvelopeReceiverQueryBase.cs
+++ b/EnvelopeGenerator.Application/Common/Query/EnvelopeReceiverQueryBase.cs
@@ -1,62 +0,0 @@
 using DigitalData.Core.Exceptions;
 using EnvelopeGenerator.Application.Common.Extensions;
 namespace EnvelopeGenerator.Application.Common.Query;
 /// <summary>
 /// 
 /// </summary>
 public record EnvelopeReceiverQueryBase : EnvelopeReceiverQueryBase<EnvelopeQueryBase, ReceiverQueryBase>;
 /// <summary>
 /// 
 /// </summary>
 /// <typeparam name="TEnvelopeQuery"></typeparam>
 /// <typeparam name="TReceiverQuery"></typeparam>
 public record EnvelopeReceiverQueryBase<TEnvelopeQuery, TReceiverQuery>
    where TEnvelopeQuery : EnvelopeQueryBase, new()
    where TReceiverQuery : ReceiverQueryBase, new()
 {
    private string? _key;
    /// <summary>
    /// 
    /// </summary>
    public virtual string? Key
    {
        get => _key;
        set
        {
            if (value is null)
            {
                _key = null;
                return;
            }
            (string? EnvelopeUuid, string? ReceiverSignature) = value.DecodeEnvelopeReceiverId();
            if (string.IsNullOrEmpty(EnvelopeUuid) || string.IsNullOrEmpty(ReceiverSignature))
                throw new BadRequestException("Der EnvelopeReceiverKey muss ein gültiger Base64-kodierter String sein, der die EnvelopeUuid und die ReceiverSignature enthält.");
            Envelope = new TEnvelopeQuery()
            {
                Uuid = EnvelopeUuid
            };
            Receiver = new TReceiverQuery()
            {
                Signature = ReceiverSignature
            };
            _key = value;
        }
    }
    /// <summary>
    /// Repräsentiert eine Abfrage für Umschläge.
    /// </summary>
    public virtual TEnvelopeQuery Envelope { get; set; } = new();
    /// <summary>
    /// Stellt eine Abfrage dar, um die Details eines Empfängers zu lesen.
    /// um spezifische Informationen über einen Empfänger abzurufen.
    /// </summary>
    public virtual TReceiverQuery Receiver { get; set; } = new();
 }
--- a/EnvelopeGenerator.Application/Common/Query/MappingProfile.cs
+++ b/EnvelopeGenerator.Application/Common/Query/MappingProfile.cs
@@ -1,20 +0,0 @@
 using AutoMapper;
 using EnvelopeGenerator.Domain.Entities;
 namespace EnvelopeGenerator.Application.Common.Query;
 /// <summary>
 /// 
 /// </summary>
 public class MappingProfile : Profile
 {
    /// <summary>
    /// 
    /// </summary>
    public MappingProfile()
    {
        CreateMap<EnvelopeQueryBase, Envelope>();
        CreateMap<ReceiverQueryBase, Receiver>();
        CreateMap<EnvelopeReceiverQueryBase, EnvelopeReceiver>();
    }
 }
--- a/EnvelopeGenerator.Application/Common/Query/ReceiverQueryBase.cs
+++ b/EnvelopeGenerator.Application/Common/Query/ReceiverQueryBase.cs
@@ -1,33 +0,0 @@
 namespace EnvelopeGenerator.Application.Common.Query;
 /// <summary>
 /// Stellt eine Abfrage dar, um die Details eines Empfängers zu lesen.
 /// um spezifische Informationen über einen Empfänger abzurufen.
 /// </summary>
 public record ReceiverQueryBase
 {
    /// <summary>
    /// ID des Empfängers
    /// </summary>
    public virtual int? Id { get; set; }
    /// <summary>
    /// E-Mail Adresse des Empfängers
    /// </summary>
    public virtual string? EmailAddress { get; set; }
    /// <summary>
    /// Eindeutige Signatur des Empfängers
    /// </summary>
    public virtual string? Signature { get; set; }
    /// <summary>
    /// Checks whether any of the specified query criteria have a value.
    /// </summary>
    /// <remarks>
    /// This property returns <c>true</c> if at least one of the fields 
    /// <see cref="Id"/>, <see cref="EmailAddress"/>, or <see cref="Signature"/> is not null.
    /// <para>Usage example: The query can be executed only if at least one criterion is specified.</para>
    /// </remarks>
    public bool HasAnyCriteria => Id is not null || EmailAddress is not null || Signature is not null;
 }
--- a/EnvelopeGenerator.Application/Common/Configurations/AuthenticatorParams.cs
+++ b/EnvelopeGenerator.Application/Common/Configurations/AuthenticatorParams.cs
@@ -1,4 +1,4 @@
-namespace EnvelopeGenerator.Application.Common.Configurations;
+namespace EnvelopeGenerator.Application.Configurations;
 /// <summary>
 /// 
--- a/EnvelopeGenerator.Application/Configurations/DbTriggerParams.cs
+++ b/EnvelopeGenerator.Application/Configurations/DbTriggerParams.cs
@@ -0,0 +1,8 @@
 namespace EnvelopeGenerator.Application.Configurations;
 /// <summary>
 /// 
 /// </summary>
 public class DbTriggerParams : Dictionary<string, ICollection<string>>
 {
 }
--- a/EnvelopeGenerator.Application/Common/Configurations/DispatcherParams.cs
+++ b/EnvelopeGenerator.Application/Common/Configurations/DispatcherParams.cs
@@ -1,4 +1,4 @@
-namespace EnvelopeGenerator.Application.Common.Configurations;
+namespace EnvelopeGenerator.Application.Configurations;
 /// <summary>
 /// 
@@ -23,5 +23,5 @@ public class DispatcherParams
    /// <summary>
    /// Default value is string.Empty
    /// </summary>
-    public string? EmailAttmt1 { get; init; } = null;
+    public string EmailAttmt1 { get; init; } = string.Empty;
 }
--- a/EnvelopeGenerator.Application/Common/Configurations/GtxMessagingParams.cs
+++ b/EnvelopeGenerator.Application/Common/Configurations/GtxMessagingParams.cs
@@ -1,5 +1,5 @@
 using DigitalData.Core.Client.Interface;
-namespace EnvelopeGenerator.Application.Common.Configurations;
+namespace EnvelopeGenerator.Application.Configurations;
 /// <summary>
 /// https://www.gtx-messaging.com/en/api-docs/sms-rest-api/
--- a/EnvelopeGenerator.Application/Common/Configurations/MailParams.cs
+++ b/EnvelopeGenerator.Application/Common/Configurations/MailParams.cs
@@ -1,4 +1,4 @@
-namespace EnvelopeGenerator.Application.Common.Configurations;
+namespace EnvelopeGenerator.Application.Configurations;
 /// <summary>
 /// 
--- a/EnvelopeGenerator.Application/Common/Configurations/TotpSmsParams.cs
+++ b/EnvelopeGenerator.Application/Common/Configurations/TotpSmsParams.cs
@@ -1,7 +1,7 @@
 using OtpNet;
 using System.Globalization;
-namespace EnvelopeGenerator.Application.Common.Configurations;
+namespace EnvelopeGenerator.Application.Configurations;
 /// <summary>
 /// 
--- a/EnvelopeGenerator.Application/Common/Interfaces/Repositories/IConfigRepository.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Repositories/IConfigRepository.cs
@@ -1,7 +1,7 @@
 using DigitalData.Core.Abstraction.Application.Repository;
 using EnvelopeGenerator.Domain.Entities;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Repositories;
+namespace EnvelopeGenerator.Application.Contracts.Repositories;
 /// <summary>
 /// 
--- a/EnvelopeGenerator.Application/Common/Interfaces/Repositories/IDocumentReceiverElementRepository.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Repositories/IDocumentReceiverElementRepository.cs
@@ -1,11 +1,11 @@
 using DigitalData.Core.Abstraction.Application.Repository;
 using EnvelopeGenerator.Domain.Entities;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Repositories;
+namespace EnvelopeGenerator.Application.Contracts.Repositories;
 /// <summary>
 /// 
 /// </summary>
 [Obsolete("Use IRepository")]
-public interface IDocumentReceiverElementRepository : ICRUDRepository<Signature, int>
+public interface IDocumentReceiverElementRepository : ICRUDRepository<DocumentReceiverElement, int>
 {
 }
--- a/EnvelopeGenerator.Application/Common/Interfaces/Repositories/IDocumentStatusRepository.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Repositories/IDocumentStatusRepository.cs
@@ -1,7 +1,7 @@
 using DigitalData.Core.Abstraction.Application.Repository;
 using EnvelopeGenerator.Domain.Entities;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Repositories;
+namespace EnvelopeGenerator.Application.Contracts.Repositories;
 /// <summary>
 /// 
--- a/EnvelopeGenerator.Application/Common/Interfaces/Repositories/IEmailTemplateRepository.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Repositories/IEmailTemplateRepository.cs
@@ -1,8 +1,8 @@
 using DigitalData.Core.Abstraction.Application.Repository;
 using EnvelopeGenerator.Domain.Constants;
 using EnvelopeGenerator.Domain.Entities;
 using static EnvelopeGenerator.Domain.Constants;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Repositories;
+namespace EnvelopeGenerator.Application.Contracts.Repositories;
 /// <summary>
 /// 
--- a/EnvelopeGenerator.Application/Contracts/Repositories/IEnvelopeCertificateRepository.cs
+++ b/EnvelopeGenerator.Application/Contracts/Repositories/IEnvelopeCertificateRepository.cs
@@ -0,0 +1,12 @@
 using DigitalData.Core.Abstraction.Application.Repository;
 using EnvelopeGenerator.Domain.Entities;
 namespace EnvelopeGenerator.Application.Contracts.Repositories;
 /// <summary>
 /// 
 /// </summary>
 [Obsolete("Use Read-method returning IReadQuery<TEntity> instead.")]
 public interface IEnvelopeCertificateRepository : ICRUDRepository<EnvelopeCertificate, int>
 {
 }
--- a/EnvelopeGenerator.Application/Common/Interfaces/Repositories/IEnvelopeDocumentRepository.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Repositories/IEnvelopeDocumentRepository.cs
@@ -1,12 +1,12 @@
 using DigitalData.Core.Abstraction.Application.Repository;
 using EnvelopeGenerator.Domain.Entities;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Repositories;
+namespace EnvelopeGenerator.Application.Contracts.Repositories;
 /// <summary>
 /// 
 /// </summary>
 [Obsolete("Use IRepository")]
-public interface IEnvelopeDocumentRepository : ICRUDRepository<Document, int>
+public interface IEnvelopeDocumentRepository : ICRUDRepository<EnvelopeDocument, int>
 {
 }
--- a/EnvelopeGenerator.Application/Common/Interfaces/Repositories/IEnvelopeHistoryRepository.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Repositories/IEnvelopeHistoryRepository.cs
@@ -1,14 +1,14 @@
 using DigitalData.Core.Abstraction.Application.Repository;
-using EnvelopeGenerator.Domain.Constants;
+using EnvelopeGenerator.Domain;
 using EnvelopeGenerator.Domain.Entities;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Repositories;
+namespace EnvelopeGenerator.Application.Contracts.Repositories;
 /// <summary>
 /// 
 /// </summary>
 [Obsolete("Use IRepository")]
-public interface IEnvelopeHistoryRepository : ICRUDRepository<History, long>
+public interface IEnvelopeHistoryRepository : ICRUDRepository<EnvelopeHistory, long>
 {
    /// <summary>
    /// 
@@ -17,7 +17,7 @@ public interface IEnvelopeHistoryRepository : ICRUDRepository<History, long>
    /// <param name="userReference"></param>
    /// <param name="status"></param>
    /// <returns></returns>
-    Task<int> CountAsync(int? envelopeId = null, string? userReference = null, EnvelopeStatus? status = null);
+    Task<int> CountAsync(int? envelopeId = null, string? userReference = null, Constants.EnvelopeStatus? status = null);
    /// <summary>
    /// 
@@ -28,5 +28,5 @@ public interface IEnvelopeHistoryRepository : ICRUDRepository<History, long>
    /// <param name="withSender"></param>
    /// <param name="withReceiver"></param>
    /// <returns></returns>
-    Task<IEnumerable<History>> ReadAsync(int? envelopeId = null, string? userReference = null, EnvelopeStatus? status = null, bool withSender = false, bool withReceiver = false);
+    Task<IEnumerable<EnvelopeHistory>> ReadAsync(int? envelopeId = null, string? userReference = null, Constants.EnvelopeStatus? status = null, bool withSender = false, bool withReceiver = false);
 }
--- a/EnvelopeGenerator.Application/Common/Interfaces/Repositories/IEnvelopeReceiverReadOnlyRepository.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Repositories/IEnvelopeReceiverReadOnlyRepository.cs
@@ -1,7 +1,7 @@
 using DigitalData.Core.Abstraction.Application.Repository;
 using EnvelopeGenerator.Domain.Entities;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Repositories;
+namespace EnvelopeGenerator.Application.Contracts.Repositories;
 /// <summary>
 /// 
--- a/EnvelopeGenerator.Application/Common/Interfaces/Repositories/IEnvelopeReceiverRepository.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Repositories/IEnvelopeReceiverRepository.cs
@@ -1,9 +1,7 @@
 using DigitalData.Core.Abstraction.Application.Repository;
 using EnvelopeGenerator.Application.Envelopes.Queries;
 using EnvelopeGenerator.Domain.Constants;
 using EnvelopeGenerator.Domain.Entities;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Repositories;
+namespace EnvelopeGenerator.Application.Contracts.Repositories;
 /// <summary>
 /// 
@@ -85,7 +83,7 @@ public interface IEnvelopeReceiverRepository : ICRUDRepository<EnvelopeReceiver,
    /// <param name="max_status"></param>
    /// <param name="ignore_statuses"></param>
    /// <returns></returns>
-    Task<IEnumerable<EnvelopeReceiver>> ReadByUsernameAsync(string username, EnvelopeStatus? min_status = null, EnvelopeStatus? max_status = null, params EnvelopeStatus[] ignore_statuses);
+    Task<IEnumerable<EnvelopeReceiver>> ReadByUsernameAsync(string username, int? min_status = null, int? max_status = null, params int[] ignore_statuses);
    /// <summary>
    /// 
--- a/EnvelopeGenerator.Application/Common/Interfaces/Repositories/IEnvelopeRepository.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Repositories/IEnvelopeRepository.cs
@@ -1,8 +1,7 @@
 using DigitalData.Core.Abstraction.Application.Repository;
 using EnvelopeGenerator.Domain.Constants;
 using EnvelopeGenerator.Domain.Entities;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Repositories;
+namespace EnvelopeGenerator.Application.Contracts.Repositories;
 /// <summary>
 /// 
@@ -39,5 +38,5 @@ public interface IEnvelopeRepository : ICRUDRepository<Envelope, int>
    /// <param name="max_status"></param>
    /// <param name="ignore_statuses"></param>
    /// <returns></returns>
-    Task<IEnumerable<Envelope>> ReadByUserAsync(int userId, EnvelopeStatus? min_status = null, EnvelopeStatus? max_status = null, params EnvelopeStatus[] ignore_statuses);
+    Task<IEnumerable<Envelope>> ReadByUserAsync(int userId, int? min_status = null, int? max_status = null, params int[] ignore_statuses);
 }
--- a/EnvelopeGenerator.Application/Common/Interfaces/Repositories/IEnvelopeTypeRepository.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Repositories/IEnvelopeTypeRepository.cs
@@ -1,7 +1,7 @@
 using DigitalData.Core.Abstraction.Application.Repository;
 using EnvelopeGenerator.Domain.Entities;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Repositories;
+namespace EnvelopeGenerator.Application.Contracts.Repositories;
 /// <summary>
 /// 
--- a/EnvelopeGenerator.Application/Common/Interfaces/Repositories/IReceiverRepository.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Repositories/IReceiverRepository.cs
@@ -1,7 +1,7 @@
 using DigitalData.Core.Abstraction.Application.Repository;
 using EnvelopeGenerator.Domain.Entities;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Repositories;
+namespace EnvelopeGenerator.Application.Contracts.Repositories;
 /// <summary>
 /// 
--- a/EnvelopeGenerator.Application/Common/Interfaces/SQLExecutor/IDocumentExecutor.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/SQLExecutor/IDocumentExecutor.cs
@@ -1,6 +1,6 @@
 using EnvelopeGenerator.Domain.Entities;
-namespace EnvelopeGenerator.Application.Common.Interfaces.SQLExecutor;
+namespace EnvelopeGenerator.Application.Contracts.SQLExecutor;
 /// <summary>
 /// 
@@ -14,5 +14,5 @@ public interface IDocumentExecutor
    /// <param name="envelope_uuid"></param>
    /// <param name="cancellation"></param>
    /// <returns></returns>
-    Task<Document> CreateDocumentAsync(string base64, string envelope_uuid, CancellationToken cancellation = default);
+    Task<EnvelopeDocument> CreateDocumentAsync(string base64, string envelope_uuid, CancellationToken cancellation = default);
 }
--- a/EnvelopeGenerator.Application/Common/Interfaces/SQLExecutor/IEnvelopeExecutor.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/SQLExecutor/IEnvelopeExecutor.cs
@@ -1,7 +1,7 @@
 using Dapper;
 using EnvelopeGenerator.Domain.Entities;
-namespace EnvelopeGenerator.Application.Common.Interfaces.SQLExecutor;
+namespace EnvelopeGenerator.Application.Contracts.SQLExecutor;
 /// <summary>
 /// 
--- a/EnvelopeGenerator.Application/Common/Interfaces/SQLExecutor/IEnvelopeReceiverExecutor.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/SQLExecutor/IEnvelopeReceiverExecutor.cs
@@ -1,6 +1,6 @@
 using EnvelopeGenerator.Domain.Entities;
-namespace EnvelopeGenerator.Application.Common.Interfaces.SQLExecutor;
+namespace EnvelopeGenerator.Application.Contracts.SQLExecutor;
 /// <summary>
 /// 
--- a/EnvelopeGenerator.Application/Common/Interfaces/SQLExecutor/IQuery.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/SQLExecutor/IQuery.cs
@@ -1,4 +1,4 @@
-namespace EnvelopeGenerator.Application.Common.Interfaces.SQLExecutor;
+namespace EnvelopeGenerator.Application.Contracts.SQLExecutor;
 /// <summary>
 /// Provides methods for executing common queries on a given entity type.
--- a/EnvelopeGenerator.Application/Common/Interfaces/SQLExecutor/ISQL.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/SQLExecutor/ISQL.cs
@@ -1,4 +1,4 @@
-namespace EnvelopeGenerator.Application.Common.Interfaces.SQLExecutor;
+namespace EnvelopeGenerator.Application.Contracts.SQLExecutor;
 /// <summary>
 /// Represents a raw SQL query contract.
--- a/EnvelopeGenerator.Application/Common/Interfaces/SQLExecutor/ISQLExecutor.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/SQLExecutor/ISQLExecutor.cs
@@ -1,4 +1,4 @@
-namespace EnvelopeGenerator.Application.Common.Interfaces.SQLExecutor;
+namespace EnvelopeGenerator.Application.Contracts.SQLExecutor;
 /// <summary>
 /// Defines methods for executing raw SQL queries or custom SQL query classes and returning query executors for further operations.
--- a/EnvelopeGenerator.Application/Common/Interfaces/SQLExecutor/ISQLExecutorBaseEntity.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/SQLExecutor/ISQLExecutorBaseEntity.cs
@@ -1,6 +1,6 @@
 using Dapper;
-namespace EnvelopeGenerator.Application.Common.Interfaces.SQLExecutor;
+namespace EnvelopeGenerator.Application.Contracts.SQLExecutor;
 /// <summary>
 /// 
--- a/EnvelopeGenerator.Application/Common/Interfaces/Services/IAuthenticator.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Services/IAuthenticator.cs
@@ -1,6 +1,6 @@
 using OtpNet;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+namespace EnvelopeGenerator.Application.Contracts.Services;
 /// <summary>
 /// 
--- a/EnvelopeGenerator.Application/Common/Interfaces/Services/IConfigService.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Services/IConfigService.cs
@@ -1,9 +1,9 @@
 using DigitalData.Core.Abstraction.Application;
 using DigitalData.Core.Abstraction.Application.DTO;
-using EnvelopeGenerator.Application.Common.Dto;
+using EnvelopeGenerator.Application.DTOs;
 using EnvelopeGenerator.Domain.Entities;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+namespace EnvelopeGenerator.Application.Contracts.Services;
 /// <summary>
 /// 
--- a/EnvelopeGenerator.Application/Common/Interfaces/Services/IDocumentReceiverElementService.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Services/IDocumentReceiverElementService.cs
@@ -1,13 +1,13 @@
 using DigitalData.Core.Abstraction.Application;
-using EnvelopeGenerator.Application.Common.Dto;
+using EnvelopeGenerator.Application.DTOs;
 using EnvelopeGenerator.Domain.Entities;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+namespace EnvelopeGenerator.Application.Contracts.Services;
 /// <summary>
 /// 
 /// </summary>
 [Obsolete("Use MediatR")]
-public interface IDocumentReceiverElementService : IBasicCRUDService<SignatureDto, Signature, int>
+public interface IDocumentReceiverElementService : IBasicCRUDService<DocumentReceiverElementDto, DocumentReceiverElement, int>
 {
 }
--- a/EnvelopeGenerator.Application/Common/Interfaces/Services/IDocumentStatusService.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Services/IDocumentStatusService.cs
@@ -1,7 +1,7 @@
 using DigitalData.Core.Abstraction.Application;
-using EnvelopeGenerator.Application.Common.Dto;
+using EnvelopeGenerator.Application.DTOs;
 using EnvelopeGenerator.Domain.Entities;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+namespace EnvelopeGenerator.Application.Contracts.Services;
 /// <summary>
 /// 
--- a/EnvelopeGenerator.Application/Common/Interfaces/Services/IEmailTemplateService.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Services/IEmailTemplateService.cs
@@ -1,10 +1,10 @@
 using DigitalData.Core.Abstraction.Application;
 using DigitalData.Core.Abstraction.Application.DTO;
-using EnvelopeGenerator.Application.Common.Dto;
+using EnvelopeGenerator.Application.DTOs;
 using EnvelopeGenerator.Domain.Constants;
 using EnvelopeGenerator.Domain.Entities;
 using static EnvelopeGenerator.Domain.Constants;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+namespace EnvelopeGenerator.Application.Contracts.Services;
 /// <summary>
 /// 
--- a/EnvelopeGenerator.Application/Contracts/Services/IEnvelopeCertificateService.cs
+++ b/EnvelopeGenerator.Application/Contracts/Services/IEnvelopeCertificateService.cs
@@ -0,0 +1,13 @@
 using DigitalData.Core.Abstraction.Application;
 using EnvelopeGenerator.Application.DTOs;
 using EnvelopeGenerator.Domain.Entities;
 namespace EnvelopeGenerator.Application.Contracts.Services;
 /// <summary>
 /// 
 /// </summary>
 [Obsolete("Use MediatR")]
 public interface IEnvelopeCertificateService : IBasicCRUDService<EnvelopeCertificateDto, EnvelopeCertificate, int>
 {
 }
--- a/EnvelopeGenerator.Application/Contracts/Services/IEnvelopeDocumentService.cs
+++ b/EnvelopeGenerator.Application/Contracts/Services/IEnvelopeDocumentService.cs
@@ -0,0 +1,13 @@
 using DigitalData.Core.Abstraction.Application;
 using EnvelopeGenerator.Application.DTOs;
 using EnvelopeGenerator.Domain.Entities;
 namespace EnvelopeGenerator.Application.Contracts.Services;
 /// <summary>
 /// 
 /// </summary>
 [Obsolete("Use MediatR")]
 public interface IEnvelopeDocumentService : IBasicCRUDService<EnvelopeDocumentDto, EnvelopeDocument, int>
 {
 }
--- a/EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeHistoryService.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeHistoryService.cs
@@ -1,17 +1,17 @@
 using DigitalData.Core.Abstraction.Application;
 using DigitalData.Core.Abstraction.Application.DTO;
-using EnvelopeGenerator.Application.Common.Dto.History;
+using EnvelopeGenerator.Application.DTOs.EnvelopeHistory;
-using EnvelopeGenerator.Application.Common.Dto.Receiver;
+using EnvelopeGenerator.Application.DTOs.Receiver;
 using EnvelopeGenerator.Domain.Constants;
 using EnvelopeGenerator.Domain.Entities;
 using static EnvelopeGenerator.Domain.Constants;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+namespace EnvelopeGenerator.Application.Contracts.Services;
 /// <summary>
 /// 
 /// </summary>
 [Obsolete("Use MediatR")]
-public interface IEnvelopeHistoryService : ICRUDService<HistoryCreateDto, HistoryDto, History, long>
+public interface IEnvelopeHistoryService : ICRUDService<EnvelopeHistoryCreateDto, EnvelopeHistoryDto, EnvelopeHistory, long>
 {
    /// <summary>
    /// 
@@ -56,7 +56,7 @@ public interface IEnvelopeHistoryService : ICRUDService<HistoryCreateDto, Histor
    /// <param name="withSender"></param>
    /// <param name="withReceiver"></param>
    /// <returns></returns>
-    Task<IEnumerable<HistoryDto>> ReadAsync(int? envelopeId = null, string? userReference = null, ReferenceType? referenceType = null, EnvelopeStatus? status = null, bool withSender = false, bool withReceiver = false);
+    Task<IEnumerable<EnvelopeHistoryDto>> ReadAsync(int? envelopeId = null, string? userReference = null, ReferenceType? referenceType = null, EnvelopeStatus? status = null, bool withSender = false, bool withReceiver = false);
    /// <summary>
    /// 
@@ -64,14 +64,14 @@ public interface IEnvelopeHistoryService : ICRUDService<HistoryCreateDto, Histor
    /// <param name="envelopeId"></param>
    /// <param name="userReference"></param>
    /// <returns></returns>
-    Task<IEnumerable<HistoryDto>> ReadRejectedAsync(int envelopeId, string? userReference = null);
+    Task<IEnumerable<EnvelopeHistoryDto>> ReadRejectedAsync(int envelopeId, string? userReference = null);
    /// <summary>
    /// 
    /// </summary>
    /// <param name="envelopeId"></param>
    /// <returns></returns>
-    Task<IEnumerable<ReceiverDto>> ReadRejectingReceivers(int envelopeId);
+    Task<IEnumerable<ReceiverReadDto>> ReadRejectingReceivers(int envelopeId);
    /// <summary>
    /// 
--- a/EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeMailService.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeMailService.cs
@@ -1,10 +1,10 @@
 using DigitalData.Core.Abstraction.Application.DTO;
 using DigitalData.EmailProfilerDispatcher.Abstraction.Contracts;
-using EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiver;
+using EnvelopeGenerator.Application.DTOs.EnvelopeReceiver;
-using EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiverReadOnly;
+using EnvelopeGenerator.Application.DTOs.EnvelopeReceiverReadOnly;
-using EnvelopeGenerator.Domain.Constants;
+using EnvelopeGenerator.Domain;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+namespace EnvelopeGenerator.Application.Contracts.Services;
 /// <summary>
 /// 
@@ -19,7 +19,7 @@ public interface IEnvelopeMailService : IEmailOutService
    /// <param name="tempType"></param>
    /// <param name="optionalPlaceholders"></param>
    /// <returns></returns>
-    Task<DataResult<int>> SendAsync(EnvelopeReceiverDto envelopeReceiverDto, EmailTemplateType tempType, Dictionary<string, object>? optionalPlaceholders = null);
+    Task<DataResult<int>> SendAsync(EnvelopeReceiverDto envelopeReceiverDto, Constants.EmailTemplateType tempType, Dictionary<string, object>? optionalPlaceholders = null);
    /// <summary>
    /// 
@@ -35,4 +35,11 @@ public interface IEnvelopeMailService : IEmailOutService
    /// <param name="envelopeReceiverDto"></param>
    /// <returns></returns>
    Task<DataResult<int>> SendAccessCodeAsync(EnvelopeReceiverDto envelopeReceiverDto);
    /// <summary>
    /// 
    /// </summary>
    /// <param name="envelopeReceiverDto"></param>
    /// <returns></returns>
    Task<DataResult<int>> SendTFAQrCodeAsync(EnvelopeReceiverDto envelopeReceiverDto);
 }
--- a/EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeReceiverReadOnlyService.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeReceiverReadOnlyService.cs
@@ -1,8 +1,8 @@
 using DigitalData.Core.Abstraction.Application;
-using EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiverReadOnly;
+using EnvelopeGenerator.Application.DTOs.EnvelopeReceiverReadOnly;
 using EnvelopeGenerator.Domain.Entities;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+namespace EnvelopeGenerator.Application.Contracts.Services;
 /// <summary>
 /// 
--- a/EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeReceiverService.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeReceiverService.cs
@@ -1,16 +1,13 @@
 using CommandDotNet;
 using DigitalData.Core.Abstraction.Application;
 using DigitalData.Core.Abstraction.Application.DTO;
-using EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiver;
+using EnvelopeGenerator.Application.DTOs.EnvelopeReceiver;
-using EnvelopeGenerator.Application.Common.Dto.Messaging;
+using EnvelopeGenerator.Application.DTOs.Messaging;
 using EnvelopeGenerator.Application.Envelopes;
-using EnvelopeGenerator.Application.Envelopes.Queries;
+using EnvelopeGenerator.Application.Receivers.Queries.Read;
 using EnvelopeGenerator.Application.Receivers.Queries;
 using EnvelopeGenerator.Domain;
 using EnvelopeGenerator.Domain.Constants;
 using EnvelopeGenerator.Domain.Entities;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+namespace EnvelopeGenerator.Application.Contracts.Services;
 /// <summary>
 /// 
@@ -123,7 +120,7 @@ public interface IEnvelopeReceiverService : IBasicCRUDService<EnvelopeReceiverDt
    /// <param name="receiverQuery"></param>
    /// <param name="ignore_statuses"></param>
    /// <returns></returns>
-    Task<DataResult<IEnumerable<EnvelopeReceiverDto>>> ReadByUsernameAsync(string username, EnvelopeStatus? min_status = null, EnvelopeStatus? max_status = null, ReadEnvelopeQuery? envelopeQuery = null, ReadReceiverQuery? receiverQuery = null, params EnvelopeStatus[] ignore_statuses);
+    Task<DataResult<IEnumerable<EnvelopeReceiverDto>>> ReadByUsernameAsync(string username, int? min_status = null, int? max_status = null, EnvelopeQuery? envelopeQuery = null, ReadReceiverQuery? receiverQuery = null, params int[] ignore_statuses);
    /// <summary>
    /// 
--- a/EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeService.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeService.cs
@@ -1,10 +1,9 @@
 using DigitalData.Core.Abstraction.Application;
 using DigitalData.Core.Abstraction.Application.DTO;
-using EnvelopeGenerator.Application.Common.Dto;
+using EnvelopeGenerator.Application.DTOs;
 using EnvelopeGenerator.Domain.Constants;
 using EnvelopeGenerator.Domain.Entities;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+namespace EnvelopeGenerator.Application.Contracts.Services;
 /// <summary>
 /// 
@@ -41,5 +40,5 @@ public interface IEnvelopeService : IBasicCRUDService<EnvelopeDto, Envelope, int
    /// <param name="max_status"></param>
    /// <param name="ignore_statuses"></param>
    /// <returns></returns>
-    Task<DataResult<IEnumerable<EnvelopeDto>>> ReadByUserAsync(int userId, EnvelopeStatus? min_status = null, EnvelopeStatus? max_status = null, params EnvelopeStatus[] ignore_statuses);
+    Task<DataResult<IEnumerable<EnvelopeDto>>> ReadByUserAsync(int userId, int? min_status = null, int? max_status = null, params int[] ignore_statuses);
 }
--- a/EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeSmsHandler.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeSmsHandler.cs
@@ -1,7 +1,7 @@
-using EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiver;
+using EnvelopeGenerator.Application.DTOs.EnvelopeReceiver;
-using EnvelopeGenerator.Application.Common.Dto.Messaging;
+using EnvelopeGenerator.Application.DTOs.Messaging;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+namespace EnvelopeGenerator.Application.Contracts.Services;
 /// <summary>
 /// 
--- a/EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeTypeService.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeTypeService.cs
@@ -1,8 +1,8 @@
 using DigitalData.Core.Abstraction.Application;
-using EnvelopeGenerator.Application.Common.Dto;
+using EnvelopeGenerator.Application.DTOs;
 using EnvelopeGenerator.Domain.Entities;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+namespace EnvelopeGenerator.Application.Contracts.Services;
 /// <summary>
 /// 
--- a/EnvelopeGenerator.Application/Common/Interfaces/Services/IReceiverService.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Services/IReceiverService.cs
@@ -1,16 +1,15 @@
 using DigitalData.Core.Abstraction.Application;
 using DigitalData.Core.Abstraction.Application.DTO;
-using EnvelopeGenerator.Application.Common.Dto.Receiver;
+using EnvelopeGenerator.Application.DTOs.Receiver;
 using EnvelopeGenerator.Application.Receivers.Commands;
 using EnvelopeGenerator.Domain.Entities;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+namespace EnvelopeGenerator.Application.Contracts.Services;
 /// <summary>
 /// 
 /// </summary>
 [Obsolete("Use MediatR")]
-public interface IReceiverService : ICRUDService<CreateReceiverCommand, ReceiverDto, Receiver, int>
+public interface IReceiverService : ICRUDService<ReceiverCreateDto, ReceiverReadDto, Receiver, int>
 {
    /// <summary>
    /// 
@@ -18,7 +17,7 @@ public interface IReceiverService : ICRUDService<CreateReceiverCommand, Receiver
    /// <param name="emailAddress"></param>
    /// <param name="signature"></param>
    /// <returns></returns>
-    Task<DataResult<ReceiverDto>> ReadByAsync(string? emailAddress = null, string? signature = null);
+    Task<DataResult<ReceiverReadDto>> ReadByAsync(string? emailAddress = null, string? signature = null);
    /// <summary>
    /// 
--- a/EnvelopeGenerator.Application/Common/Interfaces/Services/ISmsSender.cs
+++ b/EnvelopeGenerator.Application/Common/Interfaces/Services/ISmsSender.cs
@@ -1,6 +1,6 @@
-using EnvelopeGenerator.Application.Common.Dto.Messaging;
+using EnvelopeGenerator.Application.DTOs.Messaging;
-namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+namespace EnvelopeGenerator.Application.Contracts.Services;
 //TODO: move to DigitalData.Core
 /// <summary>
--- a/EnvelopeGenerator.Application/Common/Dto/ConfigDto.cs
+++ b/EnvelopeGenerator.Application/Common/Dto/ConfigDto.cs
@@ -1,6 +1,6 @@
 using Microsoft.AspNetCore.Mvc;
-namespace EnvelopeGenerator.Application.Common.Dto;
+namespace EnvelopeGenerator.Application.DTOs;
 /// <summary>
 /// Data Transfer Object representing configuration settings.
--- a/EnvelopeGenerator.Application/DTOs/DocumentReceiverElementDto.cs
+++ b/EnvelopeGenerator.Application/DTOs/DocumentReceiverElementDto.cs
@@ -1,13 +1,12 @@
-using EnvelopeGenerator.Domain.Interfaces;
+using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc;
-namespace EnvelopeGenerator.Application.Common.Dto;
+namespace EnvelopeGenerator.Application.DTOs;
 /// <summary>
 /// Data Transfer Object representing a positioned element assigned to a document receiver.
 /// </summary>
 [ApiExplorerSettings(IgnoreApi = true)]
-public class SignatureDto : ISignature
+public class DocumentReceiverElementDto
 {
    /// <summary>
    /// Gets or sets the unique identifier of the element.
@@ -87,10 +86,10 @@ public class SignatureDto : ISignature
    /// <summary>
    /// Gets or sets the top position of the element (in layout terms).
    /// </summary>
-    public double Top => Y;
+    public double Top { get; set; }
    /// <summary>
    /// Gets or sets the left position of the element (in layout terms).
    /// </summary>
-    public double Left => X;
+    public double Left { get; set; }
 }
--- a/EnvelopeGenerator.Application/Common/Dto/DocumentStatusDto.cs
+++ b/EnvelopeGenerator.Application/Common/Dto/DocumentStatusDto.cs
@@ -1,7 +1,6 @@
-using EnvelopeGenerator.Domain.Constants;
+using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc;
-namespace EnvelopeGenerator.Application.Common.Dto;
+namespace EnvelopeGenerator.Application.DTOs;
 /// <summary>
 /// Data Transfer Object representing the status of a document for a specific receiver.
@@ -27,7 +26,7 @@ public class DocumentStatusDto
    /// <summary>
    /// Gets or sets the current status code.
    /// </summary>
-    public EnvelopeStatus Status { get; set; }
+    public int Status { get; set; }
    /// <summary>
    /// Gets or sets the timestamp when the status was changed.
--- a/EnvelopeGenerator.Application/Common/Dto/EmailTemplateDto.cs
+++ b/EnvelopeGenerator.Application/Common/Dto/EmailTemplateDto.cs
@@ -1,6 +1,6 @@
 using Microsoft.AspNetCore.Mvc;
-namespace EnvelopeGenerator.Application.Common.Dto
+namespace EnvelopeGenerator.Application.DTOs
 {
    /// <summary>
    /// 
--- a/EnvelopeGenerator.Application/DTOs/EnvelopeCertificateDto.cs
+++ b/EnvelopeGenerator.Application/DTOs/EnvelopeCertificateDto.cs
@@ -0,0 +1,50 @@
 using Microsoft.AspNetCore.Mvc;
 namespace EnvelopeGenerator.Application.DTOs;
 /// <summary>
 /// Data Transfer Object representing certificate information for an envelope.
 /// </summary>
 [ApiExplorerSettings(IgnoreApi = true)]
 public class EnvelopeCertificateDto
 {
    /// <summary>
    /// Gets the unique identifier of the certificate.
    /// </summary>
    public int Id { get; init; }
    /// <summary>
    /// Gets the envelope ID associated with the certificate.
    /// </summary>
    public int EnvelopeId { get; init; }
    /// <summary>
    /// Gets the UUID of the envelope.
    /// </summary>
    public string EnvelopeUuid { get; init; } = string.Empty;
    /// <summary>
    /// Gets the subject of the envelope.
    /// </summary>
    public string EnvelopeSubject { get; init; } = string.Empty;
    /// <summary>
    /// Gets the ID of the creator of the envelope.
    /// </summary>
    public int CreatorId { get; init; }
    /// <summary>
    /// Gets the name of the creator.
    /// </summary>
    public string CreatorName { get; init; } = string.Empty;
    /// <summary>
    /// Gets the email address of the creator.
    /// </summary>
    public string CreatorEmail { get; init; } = string.Empty;
    /// <summary>
    /// Gets the current status of the envelope.
    /// </summary>
    public int EnvelopeStatus { get; init; }
 }
--- a/EnvelopeGenerator.Application/DTOs/EnvelopeDocumentDto.cs
+++ b/EnvelopeGenerator.Application/DTOs/EnvelopeDocumentDto.cs
@@ -1,12 +1,12 @@
 using Microsoft.AspNetCore.Mvc;
-namespace EnvelopeGenerator.Application.Common.Dto;
+namespace EnvelopeGenerator.Application.DTOs;
 /// <summary>
 /// Data Transfer Object representing a document within an envelope, including optional binary data and form elements.
 /// </summary>
 [ApiExplorerSettings(IgnoreApi = true)]
-public class DocumentDto
+public class EnvelopeDocumentDto
 {
    /// <summary>
    /// Gets or sets the unique identifier of the document.
@@ -31,5 +31,5 @@ public class DocumentDto
    /// <summary>
    /// Gets or sets the collection of elements associated with the document for receiver interactions, if any.
    /// </summary>
-    public IEnumerable<SignatureDto>? Elements { get; set; }
+    public IEnumerable<DocumentReceiverElementDto>? Elements { get; set; }
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Developer01	1e2e018f7f	MS Anpassungen	2025-11-12 21:43:50 +01:00
Developer01	69afea012b	Handling InsertReceivers und kleinigkeiten frm Main	2025-09-16 09:00:43 +02:00
Developer01	85e0bc3400	Logging wegen Y-Konstante	2025-09-04 14:35:54 +02:00