Replace resource strings with hardcoded English messages

All user-facing messages previously using resource strings have been changed to hardcoded English text. This affects MsgBox dialogs, Worker.ReportProgress updates, and exception messages, removing localization support and standardizing messages to plain English.
Use localized status messages from Resources.Envelope
2026-02-18 08:48:52 +01:00 · 2026-02-17 16:46:43 +01:00 · 2026-02-16 15:05:54 +01:00 · 2026-02-10 08:42:14 +01:00 · 2026-02-10 08:38:45 +01:00 · 2025-11-12 21:43:50 +01:00
652 changed files with 26783 additions and 24633 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(Policy = AuthPolicy.Receiver)]
 [ApiController]
 [Route("api/[controller]")]
 public class AnnotationController : ControllerBase
 {
    [Obsolete("Use MediatR")]
    private readonly IEnvelopeHistoryService _historyService;
    [Obsolete("Use MediatR")]
    private readonly IEnvelopeReceiverService _envelopeReceiverService;
    private readonly IMediator _mediator;
    private readonly ILogger<AnnotationController> _logger;
    /// <summary>
    /// Initializes a new instance of <see cref="AnnotationController"/>.
    /// </summary>
    [Obsolete("Use MediatR")]
    public AnnotationController(
        ILogger<AnnotationController> logger,
        IEnvelopeHistoryService envelopeHistoryService,
        IEnvelopeReceiverService envelopeReceiverService,
        IMediator mediator)
    {
        _historyService = envelopeHistoryService;
        _envelopeReceiverService = envelopeReceiverService;
        _mediator = mediator;
        _logger = logger;
    }
    /// <summary>
    /// Creates or updates annotations for the authenticated envelope receiver.
    /// </summary>
    /// <param name="psPdfKitAnnotation">Annotation payload.</param>
    /// <param name="cancel">Cancellation token.</param>
    [Authorize(Policy = AuthPolicy.Receiver)]
    [HttpPost]
    [Obsolete("PSPDF Kit will no longer be used.")]
    public async Task<IActionResult> CreateOrUpdate([FromBody] PsPdfKitAnnotation? psPdfKitAnnotation = null, CancellationToken cancel = default)
    {
        var signature = User.GetReceiverSignatureOfReceiver();
        var uuid = User.GetEnvelopeUuidOfReceiver();
        var envelopeReceiver = await _mediator.ReadEnvelopeReceiverAsync(uuid, signature, cancel).ThrowIfNull(Exceptions.NotFound);
        if (!envelopeReceiver.Envelope!.ReadOnly && psPdfKitAnnotation is null)
            return BadRequest();
        if (await _mediator.IsSignedAsync(uuid, signature, cancel))
            return Problem(statusCode: StatusCodes.Status409Conflict);
        else if (await _mediator.AnyHistoryAsync(uuid, new[] { EnvelopeStatus.EnvelopeRejected, EnvelopeStatus.DocumentRejected }, cancel))
            return Problem(statusCode: StatusCodes.Status423Locked);
        var docSignedNotification = await _mediator
            .ReadEnvelopeReceiverAsync(uuid, signature, cancel)
            .ToDocSignedNotification(psPdfKitAnnotation)
            ?? throw new NotFoundException("Envelope receiver is not found.");
        await _mediator.PublishSafely(docSignedNotification, cancel);
        await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
        return Ok();
    }
    /// <summary>
    /// Rejects the document for the current receiver.
    /// </summary>
    /// <param name="reason">Optional rejection reason.</param>
    [Authorize(Policy = AuthPolicy.Receiver)]
    [HttpPost("reject")]
    [Obsolete("Use MediatR")]
    public async Task<IActionResult> Reject([FromBody] string? reason = null)
    {
        var signature = User.GetReceiverSignatureOfReceiver();
        var uuid = User.GetEnvelopeUuidOfReceiver();
        var mail = User.GetReceiverMailOfReceiver();
        var envRcvRes = await _envelopeReceiverService.ReadByUuidSignatureAsync(uuid: uuid, signature: signature);
        if (envRcvRes.IsFailed)
        {
            _logger.LogNotice(envRcvRes.Notices);
            return Unauthorized("you are not authorized");
        }
        var histRes = await _historyService.RecordAsync(envRcvRes.Data.EnvelopeId, userReference: mail, EnvelopeStatus.DocumentRejected, comment: reason);
        if (histRes.IsSuccess)
        {
            await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
            return NoContent();
        }
        _logger.LogEnvelopeError(uuid: uuid, signature: signature, message: "Unexpected error happened in api/envelope/reject");
        _logger.LogNotice(histRes.Notices);
        return StatusCode(500, histRes.Messages);
    }
 }
--- a/EnvelopeGenerator.API/Controllers/AuthController.cs
+++ b/EnvelopeGenerator.API/Controllers/AuthController.cs
@@ -1,76 +0,0 @@
 using EnvelopeGenerator.API.Controllers.Interfaces;
 using EnvelopeGenerator.API.Models;
 using EnvelopeGenerator.Domain.Constants;
 using Microsoft.AspNetCore.Authentication;
 using Microsoft.AspNetCore.Authentication.Cookies;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Options;
 namespace EnvelopeGenerator.API.Controllers;
 /// <summary>
 /// Controller verantwortlich für die Benutzer-Authentifizierung, einschließlich Anmelden, Abmelden und Überprüfung des Authentifizierungsstatus.
 /// </summary>
 [Route("api/[controller]")]
 [ApiController]
 public partial class AuthController(IOptions<AuthTokenKeys> authTokenKeyOptions, IAuthorizationService authService) : ControllerBase, IAuthController
 {
    private readonly AuthTokenKeys authTokenKeys = authTokenKeyOptions.Value;
    /// <summary>
    /// 
    /// </summary>
    public IAuthorizationService AuthService { get; } = authService;
    /// <summary>
    /// Entfernt das Authentifizierungs-Cookie des Benutzers (AuthCookie)
    /// </summary>
    /// <returns>
    /// Gibt eine HTTP 200 oder 401.
    /// </returns>
    /// <remarks>
    /// Sample request:
    ///
    ///     POST /api/auth/logout
    ///
    /// </remarks>
    /// <response code="200">Erfolgreich gelöscht, wenn der Benutzer ein berechtigtes Cookie hat.</response>
    /// <response code="401">Wenn es kein zugelassenes Cookie gibt, wird „nicht zugelassen“ zurückgegeben.</response>
    [ProducesResponseType(typeof(void), StatusCodes.Status200OK)]
    [ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
    [Authorize(Policy = AuthPolicy.SenderOrReceiver)]
    [HttpPost("logout")]
    public async Task<IActionResult> Logout()
    {
        if (await this.IsUserInPolicyAsync(AuthPolicy.Sender))
            Response.Cookies.Delete(authTokenKeys.Cookie);
        else if (await this.IsUserInPolicyAsync(AuthPolicy.ReceiverOrReceiverTFA))
            await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
        else
            return Unauthorized();
        return Ok();
    }
    /// <summary>
    /// Prüft, ob der Benutzer ein autorisiertes Token hat.
    /// </summary>
    /// <returns>Wenn ein autorisiertes Token vorhanden ist HTTP 200 asynchron 401</returns>
    /// <remarks>
    /// Sample request:
    ///
    ///     GET /api/auth
    ///
    /// </remarks>
    /// <response code="200">Wenn es einen autorisierten Cookie gibt.</response>
    /// <response code="401">Wenn kein Cookie vorhanden ist oder nicht autorisierte.</response>
    [ProducesResponseType(typeof(void), StatusCodes.Status200OK)]
    [ProducesResponseType(typeof(void), StatusCodes.Status401Unauthorized)]
    [HttpGet("check")]
    [Authorize]
    public IActionResult Check(string? role = null)
        => role is not null && !User.IsInRole(role)
            ? Unauthorized()
            : Ok();
 }
--- 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,63 +0,0 @@
 using EnvelopeGenerator.API.Controllers.Interfaces;
 using EnvelopeGenerator.API.Extensions;
 using EnvelopeGenerator.Application.Documents.Queries;
 using EnvelopeGenerator.Domain.Constants;
 using MediatR;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 namespace EnvelopeGenerator.API.Controllers;
 /// <summary>
 /// Provides access to envelope documents for authenticated receivers.
 /// </summary>
 /// <remarks>
 /// Initializes a new instance of the <see cref="DocumentController"/> class.
 /// </remarks>
 [Authorize]
 [ApiController]
 [Route("api/[controller]")]
 public class DocumentController(IMediator mediator, IAuthorizationService authService) : ControllerBase, IAuthController
 {
    /// <summary>
    /// 
    /// </summary>
    public IAuthorizationService AuthService => authService;
    /// <summary>
    /// Returns the document bytes receiver.
    /// </summary>
    /// <param name="query">Encoded envelope key.</param>
    /// <param name="cancel">Cancellation token.</param>
    [HttpGet]
    [Authorize(Policy = AuthPolicy.SenderOrReceiver)]
    public async Task<IActionResult> GetDocument(CancellationToken cancel, [FromQuery] ReadDocumentQuery? query = null)
    {
        // Sender: expects query with envelope key
        if (await this.IsUserInPolicyAsync(AuthPolicy.Sender))
        {
            if (query is null)
                return BadRequest("Missing document query.");
            var senderDoc = await mediator.Send(query, cancel);
            return senderDoc.ByteData is byte[] senderDocByte
                ? File(senderDocByte, "application/octet-stream")
                : NotFound("Document is empty.");
        }
        // Receiver: resolve envelope id from claims
        if (await this.IsUserInPolicyAsync(AuthPolicy.Receiver))
        {           
            if (query is not null)
                return BadRequest("Query parameters are not allowed for receiver role.");
            var envelopeId = User.GetEnvelopeIdOfReceiver();
            var receiverDoc = await mediator.Send(new ReadDocumentQuery { EnvelopeId = envelopeId }, cancel);
            return receiverDoc.ByteData is byte[] receiverDocByte
                ? File(receiverDocByte, "application/octet-stream")
                : NotFound("Document is empty.");
        }
        return Unauthorized();
    }
 }
--- a/EnvelopeGenerator.API/Controllers/EmailTemplateController.cs
+++ b/EnvelopeGenerator.API/Controllers/EmailTemplateController.cs
@@ -1,69 +0,0 @@
 using AutoMapper;
 using EnvelopeGenerator.Application.EmailTemplates.Commands;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using MediatR;
 using EnvelopeGenerator.Application.Common.Dto;
 using DigitalData.Core.Abstraction.Application.Repository;
 using EnvelopeGenerator.Domain.Entities;
 using Microsoft.EntityFrameworkCore;
 using EnvelopeGenerator.Domain.Constants;
 using EnvelopeGenerator.Application.EmailTemplates.Queries;
 namespace EnvelopeGenerator.API.Controllers;
 /// <summary>
 /// Controller for managing temp templates.
 /// Steuerung zur Verwaltung von E-Mail-Vorlagen.
 /// </summary>
 /// <remarks>
 /// Initialisiert eine neue Instanz der <see cref="EmailTemplateController"/>-Klasse.
 /// </remarks>
 /// <param name="mediator">
 /// Die Mediator-Instanz, die zum Senden von Befehlen und Abfragen verwendet wird.
 /// </param>
 [Route("api/[controller]")]
 [ApiController]
 [Authorize(Policy = AuthPolicy.Sender)]
 public class EmailTemplateController(IMediator mediator) : ControllerBase
 {
    /// <summary>
    /// Ruft E-Mail-Vorlagen basierend auf der angegebenen Abfrage ab.
    /// Gibt alles zurück, wenn keine Id- oder Typ-Informationen eingegeben wurden.
    /// </summary>
    /// <param name="emailTemplate">Die Abfrageparameter zum Abrufen von E-Mail-Vorlagen.</param>
    /// <param name="cancel"></param>
    /// <returns>Gibt HTTP-Antwort zurück</returns>
    /// <remarks>
    /// Sample request:
    /// GET /api/EmailTemplate?emailTemplateId=123
    /// </remarks>
    /// <response code="200">Wenn die E-Mail-Vorlagen erfolgreich abgerufen werden.</response>
    /// <response code="400">Wenn die Abfrageparameter ungültig sind.</response>
    /// <response code="401">Wenn der Benutzer nicht authentifiziert ist.</response>
    /// <response code="404">Wenn die gesuchte Abfrage nicht gefunden wird.</response>
    [HttpGet]
    public async Task<IActionResult> Get([FromQuery] ReadEmailTemplateQuery emailTemplate, CancellationToken cancel)
    {
        var result = await mediator.Send(emailTemplate, cancel);
        return Ok(result);
    }
    /// <summary>
    /// Updates an temp template or resets it if no update command is provided.
    /// Aktualisiert eine E-Mail-Vorlage oder setzt sie zurück, wenn kein Aktualisierungsbefehl angegeben ist.
    /// </summary>
    /// <param name="update"></param>
    /// <param name="cancel"></param>
    /// <returns></returns>
    /// <response code="200">Wenn die E-Mail-Vorlage erfolgreich aktualisiert oder zurückgesetzt wird.</response>
    /// <response code="400">Wenn die Abfrage ohne einen String gesendet wird.</response>
    /// <response code="401">Wenn der Benutzer nicht authentifiziert ist.</response>
    /// <response code="404">Wenn die gesuchte Abfrage nicht gefunden wird.</response>
    [HttpPut]
    public async Task<IActionResult> Update([FromBody] UpdateEmailTemplateCommand update, CancellationToken cancel)
    {
        await mediator.Send(update, cancel);
        return Ok();
    }
 }
--- 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/Interfaces/IAuthController.cs
+++ b/EnvelopeGenerator.API/Controllers/Interfaces/IAuthController.cs
@@ -1,38 +0,0 @@
 using System.Security.Claims;
 using Microsoft.AspNetCore.Authorization;
 namespace EnvelopeGenerator.API.Controllers.Interfaces;
 /// <summary>
 /// 
 /// </summary>
 public interface IAuthController
 {
    /// <summary>
    /// 
    /// </summary>
    IAuthorizationService AuthService { get; }
    /// <summary>
    /// 
    /// </summary>
    ClaimsPrincipal User { get; }
 }
 /// <summary>
 /// 
 /// </summary>
 public static class AuthControllerExtensions
 {
    /// <summary>
    /// 
    /// </summary>
    /// <param name="controller"></param>
    /// <param name="policyName"></param>
    /// <returns></returns>
    public static async Task<bool> IsUserInPolicyAsync(this IAuthController controller, string policyName)
    {
        var result = await controller.AuthService.AuthorizeAsync(controller.User, policyName);
        return result.Succeeded;
    }
 }
--- a/EnvelopeGenerator.API/Controllers/ReadOnlyController.cs
+++ b/EnvelopeGenerator.API/Controllers/ReadOnlyController.cs
@@ -1,91 +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(Policy = AuthPolicy.Receiver)]
    [Obsolete("Use MediatR")]
    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(Policy = AuthPolicy.Receiver)]
    [HttpPost("auth/logout")]
    public async Task<IActionResult> LogOutAsync()
    {
        try
        {
            await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
            return Ok();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "{message}", ex.Message);
            return StatusCode(StatusCodes.Status500InternalServerError, new { message = _localizer.UnexpectedError() });
        }
    }
 }
--- 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/Commands/CreateCommandHandler.cs
+++ b/EnvelopeGenerator.Application/Common/Commands/CreateCommandHandler.cs
@@ -1,36 +0,0 @@
 using DigitalData.Core.Abstraction.Application.Repository;
 using MediatR;
 namespace EnvelopeGenerator.Application.Common.Commands;
 /// <summary>
 /// 
 /// </summary>
 /// <typeparam name="TCommand"></typeparam>
 /// <typeparam name="TEntity"></typeparam>
 public class CreateCommandHandler<TCommand, TEntity> : IRequestHandler<TCommand, TEntity>
    where TCommand : class, IRequest<TEntity>
    where TEntity : class
 {
    /// <summary>
    /// 
    /// </summary>
    protected readonly IRepository<TEntity> Repository;
    /// <summary>
    /// 
    /// </summary>
    /// <param name="repository"></param>
    public CreateCommandHandler(IRepository<TEntity> repository)
    {
        Repository = repository;
    }
    /// <summary>
    /// 
    /// </summary>
    /// <param name="request"></param>
    /// <param name="cancel"></param>
    /// <returns></returns>
    public Task<TEntity> Handle(TCommand request, CancellationToken cancel) => Repository.CreateAsync(request, cancel);
 }
--- a/EnvelopeGenerator.Application/Common/Commands/UpdateCommand.cs
+++ b/EnvelopeGenerator.Application/Common/Commands/UpdateCommand.cs
@@ -1,59 +0,0 @@
 using DigitalData.Core.Abstraction.Application.Repository;
 using MediatR;
 using System.Linq.Expressions;
 namespace EnvelopeGenerator.Application.Common.Commands;
 /// <summary>
 /// 
 /// </summary>
 /// <typeparam name="TUpdateDto"></typeparam>
 /// <typeparam name="TEntity"></typeparam>
 public abstract record UpdateCommand<TUpdateDto, TEntity> : IRequest where TUpdateDto : class where TEntity : class
 {
    /// <summary>
    /// 
    /// </summary>
    public TUpdateDto Update { get; init; } = null!;
    /// <summary>
    /// 
    /// </summary>
    /// <returns></returns>
    public abstract Expression<Func<TEntity, bool>> BuildQueryExpression();
 }
 /// <summary>
 /// 
 /// </summary>
 /// <typeparam name="TCommand"></typeparam>
 /// <typeparam name="TUpdateDto"></typeparam>
 /// <typeparam name="TEntity"></typeparam>
 public class UpdateCommandHandler<TCommand, TUpdateDto, TEntity> : IRequestHandler<TCommand>
    where TUpdateDto : class
    where TEntity : class
    where TCommand : UpdateCommand<TUpdateDto, TEntity>
 {
    /// <summary>
    /// 
    /// </summary>
    protected readonly IRepository<TEntity> Repository;
    /// <summary>
    /// 
    /// </summary>
    /// <param name="repository"></param>
    public UpdateCommandHandler(IRepository<TEntity> repository)
    {
        Repository = repository;
    }
    /// <summary>
    /// 
    /// </summary>
    /// <param name="request"></param>
    /// <param name="cancel"></param>
    /// <returns></returns>
    public Task Handle(TCommand request, CancellationToken cancel)
        => Repository.UpdateAsync(request.Update, request.BuildQueryExpression(), cancel);
 }
--- 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/AutoMapperAuditingExtensions.cs
+++ b/EnvelopeGenerator.Application/Common/Extensions/AutoMapperAuditingExtensions.cs
@@ -1,24 +0,0 @@
 using AutoMapper;
 using EnvelopeGenerator.Domain.Interfaces.Auditing;
 namespace EnvelopeGenerator.Application.Common.Extensions;
 /// <summary>
 /// Extension methods for applying auditing timestamps during AutoMapper mappings.
 /// </summary>
 public static class AutoMapperAuditingExtensions
 {
    /// <summary>
    /// Maps <see cref="IHasAddedWhen.AddedWhen"/> to the current UTC time.
    /// </summary>
    public static IMappingExpression<TSource, TDestination> MapAddedWhen<TSource, TDestination>(this IMappingExpression<TSource, TDestination> expression)
        where TDestination : IHasAddedWhen
        => expression.ForMember(dest => dest.AddedWhen, opt => opt.MapFrom(_ => DateTime.UtcNow));
    /// <summary>
    /// Maps <see cref="IHasChangedWhen.ChangedWhen"/> to the current UTC time.
    /// </summary>
    public static IMappingExpression<TSource, TDestination> MapChangedWhen<TSource, TDestination>(this IMappingExpression<TSource, TDestination> expression)
        where TDestination : IHasChangedWhen
        => expression.ForMember(dest => dest.ChangedWhen, opt => opt.MapFrom(_ => DateTime.UtcNow));
 }
--- 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/Show More
+++ b/Show More
Author	SHA1	Message	Date
OlgunR	341713d4cb	Replace resource strings with hardcoded English messages All user-facing messages previously using resource strings have been changed to hardcoded English text. This affects MsgBox dialogs, Worker.ReportProgress updates, and exception messages, removing localization support and standardizing messages to plain English.	2026-02-18 08:48:52 +01:00
OlgunR	f1b34dfa42	Use localized status messages from Resources.Envelope Replaced hardcoded status messages with resource-based strings for "Initializing Configuration" and "Starting Application" to improve internationalization and maintainability.	2026-02-17 16:46:43 +01:00
OlgunR	676598450d	Translate UI into English and french; Extend resources and outsource hardcoded String form codebase into resources.	2026-02-16 15:05:54 +01:00
Developer01	c0b2ad0d9b	Push nach rename	2026-02-10 08:42:14 +01:00
Developer01	2b7d797c3e	2.9.1	2026-02-10 08:38:45 +01:00
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