chore(Web): bump to 3.8.2

Added automatic injection of the envKey query parameter into all request URLs within sendRequest.
Updated URL handling to use the URL API, ensuring consistent parameter merging and preventing missing envKey issues.

EnvelopeGenerator.Application/Common/Configurations/AuthenticatorParams.cs

@@ -0,0 +1,33 @@
+namespace EnvelopeGenerator.Application.Common.Configurations;
+
+/// <summary>
+/// 
+/// </summary>
+public class AuthenticatorParams
+{
+    /// <summary>
+    /// Default value is 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567890123456789012345678901234567890123456789'
+    /// </summary>
+    public string CharPool { get; init; } = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567890123456789012345678901234567890123456789";
+
+    //TODO: Increase the DefaultTotpSecretKeyLength (e.g. to 32) but make sure that the QR code is generated correctly and can be scanned by the authenticator.
+    /// <summary>
+    /// Default value is 20
+    /// </summary>
+    public int DefaultTotpSecretKeyLength { get; init; } = 20;
+
+    /// <summary>
+    /// Default value is 
+    /// </summary>
+    public string TotpIssuer { get; init; } = "signFlow";
+
+    /// <summary>
+    /// 0 is user email, 1 is secret key and 2 is issuer.
+    /// </summary>
+    public string TotpUrlFormat { get; init; } = "otpauth://totp/{0}?secret={1}&issuer={2}";
+
+    /// <summary>
+    /// Default value is 20.
+    /// </summary>
+    public int TotpQRPixelsPerModule { get; init; } = 20;
+}

EnvelopeGenerator.Application/Common/Configurations/DispatcherParams.cs

@@ -0,0 +1,27 @@
+namespace EnvelopeGenerator.Application.Common.Configurations;
+
+/// <summary>
+/// 
+/// </summary>
+public class DispatcherParams
+{
+    /// <summary>
+    /// Default value is 1
+    /// </summary>
+    public int SendingProfile { get; init; } = 1;
+
+    /// <summary>
+    /// Defalt value is 'DDEnvelopGenerator'
+    /// </summary>
+    public string AddedWho { get; init; } = "DDEnvelopGenerator";
+
+    /// <summary>
+    /// Default value is 202377
+    /// </summary>
+    public int ReminderTypeId { get; init; } = 202377;
+
+    /// <summary>
+    /// Default value is string.Empty
+    /// </summary>
+    public string? EmailAttmt1 { get; init; } = null;
+}

EnvelopeGenerator.Application/Common/Configurations/GtxMessagingParams.cs

@@ -1,20 +1,37 @@
-using DigitalData.Core.Abstractions.Client;
-namespace EnvelopeGenerator.Application.Configurations;
+using DigitalData.Core.Client.Interface;
+namespace EnvelopeGenerator.Application.Common.Configurations;
 
 /// <summary>
 /// https://www.gtx-messaging.com/en/api-docs/sms-rest-api/
 /// </summary>
 public class GtxMessagingParams : IHttpClientOptions
 {
+    /// <summary>
+    /// 
+    /// </summary>
     public required string Uri { get; init; }
 
+    /// <summary>
+    /// 
+    /// </summary>
     public string? Path { get; init; }
 
+    /// <summary>
+    /// 
+    /// </summary>
     public Dictionary<string, object>? Headers { get; init; }
 
+    /// <summary>
+    /// 
+    /// </summary>
     public Dictionary<string, object?>? QueryParams { get; init; }
-
+    /// <summary>
+    /// Default value is 'to'
+    /// </summary>
     public string RecipientQueryParamName { get; init; } = "to";
 
+    /// <summary>
+    /// Default value is 'text'
+    /// </summary>
     public string MessageQueryParamName { get; init; } = "text";
 }

EnvelopeGenerator.Application/Common/Configurations/MailParams.cs

@@ -0,0 +1,12 @@
+namespace EnvelopeGenerator.Application.Common.Configurations;
+
+/// <summary>
+/// 
+/// </summary>
+public class MailParams
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public required Dictionary<string, string> Placeholders { get; init; }
+}

EnvelopeGenerator.Application/Common/Configurations/TotpSmsParams.cs

@@ -0,0 +1,81 @@
+using OtpNet;
+using System.Globalization;
+
+namespace EnvelopeGenerator.Application.Common.Configurations;
+
+/// <summary>
+/// 
+/// </summary>
+public class TotpSmsParams
+{
+    /// <summary>
+    /// The unit is second.
+    /// </summary>
+    public int TotpStep { get; init; } = 90;
+
+    /// <summary>
+    /// Default value is 'Ihr 2FA-Passwort lautet {0}. Gültig bis {1}'
+    /// </summary>
+    public string Format { get; init; } = "Ihr 2FA-Passwort lautet {0}. Gültig bis {1}";
+    
+    /// <summary>
+    /// 
+    /// </summary>
+    public ExpirationHandler Expiration { get; init; } = new();
+
+    /// <summary>
+    /// Default value is VerificationWindow.RfcSpecifiedNetworkDelay
+    /// </summary>
+    public VerificationWindow? TotpVerificationWindow { get; private init; } = VerificationWindow.RfcSpecifiedNetworkDelay;
+
+    private IEnumerable<int>? _tvwParams;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public IEnumerable<int>? TotpVerificationWindowParams
+    {
+        get => _tvwParams;
+        init
+        {
+            _tvwParams = value;
+            if(_tvwParams is not null)
+                TotpVerificationWindow = new(previous: _tvwParams.ElementAtOrDefault(0), future: _tvwParams.ElementAtOrDefault(0));
+        }
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public class ExpirationHandler
+    {
+        /// <summary>
+        /// Default value is 'e{0}_r{1}_sms_code_expiration'
+        /// </summary>
+        public string CacheKeyFormat { get; init; } = "e{0}_r{1}_sms_code_expiration";
+
+        /// <summary>
+        /// Default value is HH:mm:ss
+        /// </summary>
+        public string Format { get; init; } = "HH:mm:ss";
+
+        /// <summary>
+        /// Default value is 'de-DE'
+        /// </summary>
+        public string CultureName
+        {
+            get => _cultureInfo.Name;
+            init => _cultureInfo = new(value);
+        }
+
+        /// <summary>
+        /// Default value is 'de-DE'
+        /// </summary>
+        private CultureInfo _cultureInfo = new("de-DE");
+
+        /// <summary>
+        /// Default value is 'de-DE'
+        /// </summary>
+        public CultureInfo CultureInfo => _cultureInfo;
+    }
+}

EnvelopeGenerator.Application/Common/Dto/AnnotationDto.cs

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

EnvelopeGenerator.Application/Common/Dto/ConfigDto.cs

@@ -0,0 +1,30 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.Common.Dto;
+
+/// <summary>
+/// Data Transfer Object representing configuration settings.
+/// </summary>
+[ApiExplorerSettings(IgnoreApi = true)]
+public class ConfigDto
+{
+    /// <summary>
+    /// Gets or sets the sending profile identifier.
+    /// </summary>
+    public int SendingProfile { get; set; }
+
+    /// <summary>
+    /// Gets or sets the signature host URL or name.
+    /// </summary>
+    public required string SignatureHost { get; set; }
+
+    /// <summary>
+    /// Gets or sets the name of the external program.
+    /// </summary>
+    public string? ExternalProgramName { get; set; }
+
+    /// <summary>
+    /// Gets or sets the path where exports will be saved.
+    /// </summary>
+    public string? ExportPath { get; set; }
+}

EnvelopeGenerator.Application/Common/Dto/DocumentDto.cs

@@ -0,0 +1,35 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.Common.Dto;
+
+/// <summary>
+/// Data Transfer Object representing a document within an envelope, including optional binary data and form elements.
+/// </summary>
+[ApiExplorerSettings(IgnoreApi = true)]
+public class DocumentDto
+{
+    /// <summary>
+    /// Gets or sets the unique identifier of the document.
+    /// </summary>
+    public int Id { get; set; }
+
+    /// <summary>
+    /// Gets or sets the envelope ID to which the document belongs.
+    /// </summary>
+    public int EnvelopeId { get; set; }
+
+    /// <summary>
+    /// Gets or sets the date and time when the document was added.
+    /// </summary>
+    public DateTime AddedWhen { get; set; }
+
+    /// <summary>
+    /// Gets or sets the binary data of the document, if available.
+    /// </summary>
+    public byte[]? ByteData { get; set; }
+
+    /// <summary>
+    /// Gets or sets the collection of elements associated with the document for receiver interactions, if any.
+    /// </summary>
+    public IEnumerable<SignatureDto>? Elements { get; set; }
+}

EnvelopeGenerator.Application/Common/Dto/DocumentStatusDto.cs

@@ -0,0 +1,51 @@
+using EnvelopeGenerator.Domain.Constants;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.Common.Dto;
+
+/// <summary>
+/// Data Transfer Object representing the status of a document for a specific receiver.
+/// </summary>
+[ApiExplorerSettings(IgnoreApi = true)]
+public class DocumentStatusDto
+{
+    /// <summary>
+    /// Gets or sets the unique identifier of the document status entry.
+    /// </summary>
+    public int Id { get; set; }
+
+    /// <summary>
+    /// Gets or sets the ID of the associated envelope.
+    /// </summary>
+    public int EnvelopeId { get; set; }
+
+    /// <summary>
+    /// Gets or sets the ID of the receiver associated with this status.
+    /// </summary>
+    public int ReceiverId { get; set; }
+
+    /// <summary>
+    /// Gets or sets the current status code.
+    /// </summary>
+    public EnvelopeStatus Status { get; set; }
+
+    /// <summary>
+    /// Gets or sets the timestamp when the status was changed.
+    /// </summary>
+    public DateTime? StatusChangedWhen { get; set; }
+
+    /// <summary>
+    /// Gets or sets the timestamp when this record was added.
+    /// </summary>
+    public DateTime AddedWhen { get; set; }
+
+    /// <summary>
+    /// Gets or sets the timestamp when this record was last changed.
+    /// </summary>
+    public DateTime? ChangedWhen { get; set; }
+
+    /// <summary>
+    /// Gets or sets the display value associated with the status.
+    /// </summary>
+    public string? Value { get; set; }
+}

EnvelopeGenerator.Application/Common/Dto/EmailTemplateDto.cs

@@ -0,0 +1,31 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.Common.Dto
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    [ApiExplorerSettings(IgnoreApi = true)]
+    public record EmailTemplateDto
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+        public int Id{ get; init; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public required string Name { get; init; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public required string Body { get; set; }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public required string Subject { get; set; }
+    };
+}

EnvelopeGenerator.Application/Common/Dto/EnvelopeDto.cs

@@ -0,0 +1,121 @@
+using DigitalData.EmailProfilerDispatcher.Abstraction.Attributes;
+using DigitalData.UserManager.Application.DTOs.User;
+using EnvelopeGenerator.Domain.Constants;
+using EnvelopeGenerator.Domain.Entities;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.Common.Dto;
+
+/// <summary>
+/// 
+/// </summary>
+[ApiExplorerSettings(IgnoreApi = true)]
+public record EnvelopeDto
+{
+	/// <summary>
+	/// 
+	/// </summary>
+	public int Id { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public int UserId { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public required EnvelopeStatus Status { get; set; }
+
+    /// <summary>
+    /// Default value is string.Empty
+    /// </summary>
+    public string StatusName { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Default value is string.Empty
+    /// </summary>
+    public string Uuid { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Default value is string.Empty
+    /// </summary>
+    [TemplatePlaceholder("[MESSAGE]")]
+    public string Message { get; set; } = string.Empty;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public DateTime AddedWhen { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public DateTime? ChangedWhen { get; set; }
+
+    /// <summary>
+    /// Default value is string.Empty
+    /// </summary>
+    [TemplatePlaceholder("[DOCUMENT_TITLE]")]
+    public string Title { get; set; } = string.Empty;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public int? ContractType { get; set; }
+
+    /// <summary>
+    /// Default value is 'de-DE'
+    /// </summary>
+    public string Language { get; set; } = "de-DE";
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public int? EnvelopeTypeId { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public int? CertificationType { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public bool UseAccessCode { get; set; } = true;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public bool TFAEnabled { get; init; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public UserReadDto? User { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public EnvelopeType? EnvelopeType { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public string? EnvelopeTypeTitle { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public bool IsAlreadySent { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public byte[]? DocResult { get; init; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public IEnumerable<DocumentDto>? Documents { get; set; }
+}

EnvelopeGenerator.Application/Common/Dto/EnvelopeReceiver/EnvelopeReceiverDto.cs

@@ -0,0 +1,78 @@
+using DigitalData.EmailProfilerDispatcher.Abstraction.Attributes;
+using EnvelopeGenerator.Application.Common.Dto.Receiver;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiver;
+
+/// <summary>
+/// 
+/// </summary>
+[ApiExplorerSettings(IgnoreApi = true)]
+public record EnvelopeReceiverDto
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public EnvelopeDto? Envelope { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public ReceiverDto? Receiver { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public (int Envelope, int Receiver) Id => (Envelope: EnvelopeId, Receiver: ReceiverId);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public int EnvelopeId { get; init; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public int ReceiverId { get; init; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public int Sequence { get; init; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    [TemplatePlaceholder("[NAME_RECEIVER]")]
+    public string? Name { get; init; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public string? JobTitle { get; init; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public string? CompanyName { get; init; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public string? PrivateMessage { get; init; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public DateTime AddedWhen { get; init; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public DateTime? ChangedWhen { get; init; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public bool HasPhoneNumber { get; init; }
+}

EnvelopeGenerator.Application/Common/Dto/EnvelopeReceiver/EnvelopeReceiverSecretDto.cs

@@ -0,0 +1,20 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiver;
+
+/// <summary>
+/// 
+/// </summary>
+[ApiExplorerSettings(IgnoreApi = true)]
+public record EnvelopeReceiverSecretDto : EnvelopeReceiverDto
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public string? AccessCode { get; init; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public string? PhoneNumber { get; init; }
+}

EnvelopeGenerator.Application/Common/Dto/EnvelopeReceiverReadOnly/EnvelopeReceiverReadOnlyCreateDto.cs

@@ -0,0 +1,39 @@
+using Microsoft.AspNetCore.Mvc;
+using System.ComponentModel.DataAnnotations;
+using System.Text.Json.Serialization;
+
+namespace EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiverReadOnly;
+
+/// <summary>
+/// 
+/// </summary>
+/// <param name="DateValid"></param>
+[ApiExplorerSettings(IgnoreApi = true)]
+public record EnvelopeReceiverReadOnlyCreateDto(
+    DateTime DateValid)
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    [EmailAddress]
+    [Required]
+    public required string ReceiverMail { get; init; }
+
+    /// <summary>
+    /// Default value is null
+    /// </summary>
+    [JsonIgnore]
+    public long? EnvelopeId { get; set; } = null;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    [JsonIgnore]
+    public string? AddedWho { get; set; }
+
+    /// <summary>
+    /// Default value is DateTime.Now
+    /// </summary>
+    [JsonIgnore]
+    public DateTime AddedWhen { get; } = DateTime.Now;
+};

EnvelopeGenerator.Application/Common/Dto/EnvelopeReceiverReadOnly/EnvelopeReceiverReadOnlyDto.cs

@@ -0,0 +1,64 @@
+using EnvelopeGenerator.Application.Common.Dto;
+using EnvelopeGenerator.Application.Common.Dto.Receiver;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiverReadOnly;
+
+/// <summary>
+/// Represents a read-only Data Transfer Object (DTO) for an envelope receiver.
+/// Contains information about the receiver, associated envelope, and audit details.
+/// </summary>
+[ApiExplorerSettings(IgnoreApi = true)]
+public class EnvelopeReceiverReadOnlyDto
+{
+    /// <summary>
+    /// Gets or inits the unique identifier of the envelope receiver.
+    /// </summary>
+    public long Id { get; init; }
+
+    /// <summary>
+    /// Gets or inits the identifier of the associated envelope.
+    /// </summary>
+    public long EnvelopeId { get; init; }
+
+    /// <summary>
+    /// Gets or inits the email address of the receiver.
+    /// </summary>
+    public required string ReceiverMail { get; set; }
+
+    /// <summary>
+    /// Gets or inits the date until which the receiver is valid.
+    /// </summary>
+    public DateTime DateValid { get; set; }
+
+    /// <summary>
+    /// Gets or inits the date and time when the receiver was added.
+    /// </summary>
+    public DateTime AddedWhen { get; init; }
+
+    /// <summary>
+    /// Gets or inits the user who added the receiver.
+    /// Default value is 'unknown'.
+    /// </summary>
+    public string AddedWho { get; init; } = "Unknown";
+
+    /// <summary>
+    /// Gets or inits the associated envelope details.
+    /// </summary>
+    public EnvelopeDto? Envelope { get; set; }
+
+    /// <summary>
+    /// Gets or inits the user who last changed the receiver, if any.
+    /// </summary>
+    public string? ChangedWho { get; set; }
+
+    /// <summary>
+    /// Gets or inits the date and time when the receiver was last changed, if any.
+    /// </summary>
+    public DateTime? ChangedWhen { get; set; }
+
+    /// <summary>
+    /// Gets or inits the associated receiver details.
+    /// </summary>
+    public ReceiverDto? Receiver { get; set; }
+}

EnvelopeGenerator.Application/Common/Dto/EnvelopeReceiverReadOnly/EnvelopeReceiverReadOnlyUpdateDto.cs

@@ -0,0 +1,31 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiverReadOnly;
+
+/// <summary>
+/// Data Transfer Object for updating a read-only envelope receiver.
+/// </summary>
+[ApiExplorerSettings(IgnoreApi = true)]
+public class EnvelopeReceiverReadOnlyUpdateDto
+{
+    /// <summary>
+    /// Gets or sets the unique identifier of the envelope receiver.
+    /// </summary>
+    public long Id { get; init; }
+
+    /// <summary>
+    /// Gets or sets the date when the envelope receiver becomes valid.
+    /// </summary>
+    public DateTime DateValid { get; set; }
+
+    /// <summary>
+    /// Gets or sets the name of the user who made the change.
+    /// Default value is unknown.
+    /// </summary>
+    public string ChangedWho { get; set; } = "Unknown";
+
+    /// <summary>
+    /// Gets or sets the date and time when the change was made.
+    /// </summary>
+    public DateTime ChangedWhen { get; set; } = DateTime.Now;
+}

EnvelopeGenerator.Application/Common/Dto/EnvelopeTypeDto.cs

@@ -0,0 +1,85 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.Common.Dto;
+
+/// <summary>
+/// Data Transfer Object representing a type of envelope with its configuration settings.
+/// </summary>
+[ApiExplorerSettings(IgnoreApi = true)]
+public class EnvelopeTypeDto
+{
+    /// <summary>
+    /// Gets or sets the unique identifier of the envelope type.
+    /// </summary>
+    public int Id { get; set; }
+
+    /// <summary>
+    /// Gets or sets the title of the envelope type.
+    /// </summary>
+    public string Title { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Gets or sets the language code used in this envelope type.
+    /// </summary>
+    public string Language { get; set; } = "de-DE";
+
+    /// <summary>
+    /// Gets or sets the number of days after which the envelope expires.
+    /// </summary>
+    public int? ExpiresDays { get; set; }
+
+    /// <summary>
+    /// Gets or sets the certification type identifier.
+    /// </summary>
+    public int? CertificationType { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether an access code is required.
+    /// </summary>
+    public bool? UseAccessCode { get; set; }
+
+    /// <summary>
+    /// Gets or sets the final email template ID to be sent to the creator.
+    /// </summary>
+    public int? FinalEmailToCreator { get; set; }
+
+    /// <summary>
+    /// Gets or sets the final email template ID to be sent to the receivers.
+    /// </summary>
+    public int? FinalEmailToReceivers { get; set; }
+
+    /// <summary>
+    /// Gets or sets the timestamp when this envelope type was added.
+    /// </summary>
+    public DateTime AddedWhen { get; set; }
+
+    /// <summary>
+    /// Gets or sets the timestamp when this envelope type was last changed.
+    /// </summary>
+    public DateTime? ChangedWhen { get; set; }
+
+    /// <summary>
+    /// Gets or sets the number of days before expiry when a warning should be sent.
+    /// </summary>
+    public int? ExpiresWarningDays { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether reminder emails should be sent.
+    /// </summary>
+    public bool? SendReminderEmails { get; set; }
+
+    /// <summary>
+    /// Gets or sets the number of days before the first reminder is sent.
+    /// </summary>
+    public int? FirstReminderDays { get; set; }
+
+    /// <summary>
+    /// Gets or sets the interval in days between reminder emails.
+    /// </summary>
+    public int? ReminderIntervalDays { get; set; }
+
+    /// <summary>
+    /// Gets or sets the contract type associated with the envelope type.
+    /// </summary>
+    public int? ContractType { get; set; }
+}

EnvelopeGenerator.Application/Common/Dto/History/HistoryCreateDto.cs

@@ -0,0 +1,32 @@
+namespace EnvelopeGenerator.Application.Common.Dto.History;
+
+/// <summary>
+/// Data Transfer Object for creating a new envelope history record.
+/// </summary>
+public class HistoryCreateDto
+{
+    /// <summary>
+    /// Gets or sets the identifier of the envelope.
+    /// </summary>
+    public int EnvelopeId { get; set; }
+
+    /// <summary>
+    /// Gets or sets the user reference associated with the action.
+    /// </summary>
+    public required string UserReference { get; set; }
+
+    /// <summary>
+    /// Gets or sets the status of the envelope at the time of the action.
+    /// </summary>
+    public int Status { get; set; }
+
+    /// <summary>
+    /// Gets or sets the date and time when the action occurred.
+    /// </summary>
+    public DateTime? ActionDate { get; set; }
+
+    /// <summary>
+    /// Gets or sets an optional comment related to the action.
+    /// </summary>
+    public string? Comment { get; set; }
+}

EnvelopeGenerator.Application/Common/Dto/History/HistoryDto.cs

@@ -0,0 +1,74 @@
+using DigitalData.UserManager.Application.DTOs.User;
+using EnvelopeGenerator.Application.Common.Dto.Receiver;
+using EnvelopeGenerator.Domain.Constants;
+
+namespace EnvelopeGenerator.Application.Common.Dto.History;
+
+/// <summary>
+/// Data Transfer Object representing the history of an envelope, including status, sender, receiver, and related metadata.
+/// </summary>
+public record HistoryDto
+{
+    /// <summary>
+    /// Unique identifier for the envelope history entry.
+    /// </summary>
+    public long Id { get; set; }
+
+    /// <summary>
+    /// Identifier of the associated envelope.
+    /// </summary>
+    public int EnvelopeId { get; set; }
+
+    /// <summary>
+    /// Reference string for the user related to this history entry.
+    /// </summary>
+    public required string UserReference { get; set; }
+
+    /// <summary>
+    /// Include code of the envelope at this history point.
+    /// </summary>
+    public EnvelopeStatus Status { get; set; }
+
+    /// <summary>
+    /// Type of reference for this history entry.
+    /// </summary>
+    public ReferenceType ReferenceType => ((int)Status).ToString().FirstOrDefault() switch
+    {
+        '1' => ReferenceType.Sender,
+        '2' => ReferenceType.Receiver,
+        _ => ReferenceType.System,
+    };
+
+    /// <summary>
+    /// Human-readable name of the status.
+    /// </summary>
+    public string? StatusName { get; set; }
+
+    /// <summary>
+    /// Date and time when this history entry was added.
+    /// </summary>
+    public DateTime AddedWhen { get; set; }
+
+    /// <summary>
+    /// Date and time when an action was performed, if applicable.
+    /// </summary>
+    public DateTime? ActionDate { get; set; }
+
+    /// <summary>
+    /// Information about the sender associated with this history entry.
+    /// </summary>
+    public UserCreateDto? Sender { get; set; }
+
+    /// <summary>
+    /// Information about the receiver associated with this history entry.
+    /// </summary>
+    public ReceiverDto? Receiver { get; set; }
+
+    /// <summary>
+    /// Optional comment related to this history entry.
+    /// </summary>
+    public string? Comment { get; set; }
+
+    /// <inheritdoc/>
+    public override int GetHashCode() => Id.GetHashCode();
+};

EnvelopeGenerator.Application/Common/Dto/MappingProfile.cs

@@ -1,13 +1,13 @@
 using AutoMapper;
-using EnvelopeGenerator.Application.DTOs.EnvelopeHistory;
-using EnvelopeGenerator.Application.DTOs.EnvelopeReceiver;
-using EnvelopeGenerator.Application.DTOs.EnvelopeReceiverReadOnly;
-using EnvelopeGenerator.Application.DTOs.Messaging;
-using EnvelopeGenerator.Application.DTOs.Receiver;
-using EnvelopeGenerator.Application.Extensions;
+using EnvelopeGenerator.Application.Common.Dto.History;
+using EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiver;
+using EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiverReadOnly;
+using EnvelopeGenerator.Application.Common.Dto.Messaging;
+using EnvelopeGenerator.Application.Common.Dto.Receiver;
+using EnvelopeGenerator.Application.Common.Extensions;
 using EnvelopeGenerator.Domain.Entities;
 
-namespace EnvelopeGenerator.Application.DTOs;
+namespace EnvelopeGenerator.Application.Common.Dto;
 
 /// <summary>
 /// Represents the AutoMapper profile configuration for mapping between
@@ -23,42 +23,36 @@ public class MappingProfile : Profile
     {
         // Entity to DTO mappings
         CreateMap<Config, ConfigDto>();
-        CreateMap<DocumentReceiverElement, DocumentReceiverElementDto>();
+        CreateMap<Signature, SignatureDto>();
         CreateMap<DocumentStatus, DocumentStatusDto>();
         CreateMap<EmailTemplate, EmailTemplateDto>();
         CreateMap<Envelope, EnvelopeDto>();
-        CreateMap<EnvelopeCertificate, EnvelopeCertificateDto>();
-        CreateMap<EnvelopeDocument, EnvelopeDocumentDto>();
-        CreateMap<Domain.Entities.EnvelopeHistory, EnvelopeHistoryDto>();
-        CreateMap<Domain.Entities.EnvelopeHistory, EnvelopeHistoryCreateDto>();
+        CreateMap<Document, DocumentDto>();
+        CreateMap<Domain.Entities.History, HistoryDto>();
+        CreateMap<Domain.Entities.History, HistoryCreateDto>();
         CreateMap<Domain.Entities.EnvelopeReceiver, EnvelopeReceiverDto>();
         CreateMap<Domain.Entities.EnvelopeReceiver, EnvelopeReceiverSecretDto>();
         CreateMap<EnvelopeType, EnvelopeTypeDto>();
-        CreateMap<Domain.Entities.Receiver, ReceiverReadDto>();
-        CreateMap<Domain.Entities.Receiver, ReceiverCreateDto>();
-        CreateMap<Domain.Entities.Receiver, ReceiverUpdateDto>();
-        CreateMap<UserReceiver, UserReceiverDto>();
+        CreateMap<Domain.Entities.Receiver, ReceiverDto>();
         CreateMap<Domain.Entities.EnvelopeReceiverReadOnly, EnvelopeReceiverReadOnlyDto>();
+        CreateMap<ElementAnnotation, AnnotationDto>();
 
         // DTO to Entity mappings
         CreateMap<ConfigDto, Config>();
-        CreateMap<DocumentReceiverElementDto, DocumentReceiverElement>();
+        CreateMap<SignatureDto, Signature>();
         CreateMap<DocumentStatusDto, DocumentStatus>();
         CreateMap<EmailTemplateDto, EmailTemplate>();
         CreateMap<EnvelopeDto, Envelope>();
-        CreateMap<EnvelopeCertificateDto, EnvelopeCertificate>();
-        CreateMap<EnvelopeDocumentDto, EnvelopeDocument>();
-        CreateMap<EnvelopeHistoryDto, Domain.Entities.EnvelopeHistory>();
-        CreateMap<EnvelopeHistoryCreateDto, Domain.Entities.EnvelopeHistory>();
+        CreateMap<DocumentDto, Document>();
+        CreateMap<HistoryDto, Domain.Entities.History>();
+        CreateMap<HistoryCreateDto, Domain.Entities.History>();
         CreateMap<EnvelopeReceiverDto, Domain.Entities.EnvelopeReceiver>();
         CreateMap<EnvelopeTypeDto, EnvelopeType>();
-        CreateMap<ReceiverReadDto, Domain.Entities.Receiver>().ForMember(rcv => rcv.EnvelopeReceivers, rcvReadDto => rcvReadDto.Ignore());
-        CreateMap<ReceiverCreateDto, Domain.Entities.Receiver>();
-        CreateMap<ReceiverUpdateDto, Domain.Entities.Receiver>();
-        CreateMap<UserReceiverDto, UserReceiver>();
-        CreateMap<EnvelopeReceiverBase, EnvelopeReceiverBasicDto>();
+        CreateMap<ReceiverDto, Domain.Entities.Receiver>().ForMember(rcv => rcv.EnvelopeReceivers, rcvReadDto => rcvReadDto.Ignore());
         CreateMap<EnvelopeReceiverReadOnlyCreateDto, Domain.Entities.EnvelopeReceiverReadOnly>();
         CreateMap<EnvelopeReceiverReadOnlyUpdateDto, Domain.Entities.EnvelopeReceiverReadOnly>();
+        CreateMap<AnnotationCreateDto, ElementAnnotation>()
+            .ForMember(dest => dest.AddedWhen, opt => opt.MapFrom(_ => DateTime.UtcNow));
 
         // Messaging mappings
         // for GTX messaging

EnvelopeGenerator.Application/Common/Dto/Messaging/GtxMessagingResponse.cs

@@ -0,0 +1,9 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.Common.Dto.Messaging;
+
+/// <summary>
+/// 
+/// </summary>
+[ApiExplorerSettings(IgnoreApi = true)]
+public class GtxMessagingResponse : Dictionary<string, object?> { }

EnvelopeGenerator.Application/Common/Dto/Messaging/SmsResponse.cs

@@ -0,0 +1,25 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.Common.Dto.Messaging;
+
+/// <summary>
+/// 
+/// </summary>
+[ApiExplorerSettings(IgnoreApi = true)]
+public record SmsResponse
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public required bool Ok { get; init; }
+
+    /// <summary>
+    /// Returns !Ok
+    /// </summary>
+    public bool Failed => !Ok;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public dynamic? Errors { get; init; }
+}

EnvelopeGenerator.Application/Common/Dto/Receiver/ReceiverDto.cs

@@ -0,0 +1,63 @@
+using EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiver;
+using Microsoft.AspNetCore.Mvc;
+using System.Text.Json.Serialization;
+
+namespace EnvelopeGenerator.Application.Common.Dto.Receiver;
+
+/// <summary>
+/// 
+/// </summary>
+[ApiExplorerSettings(IgnoreApi = true)]
+public class ReceiverDto
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public int Id { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public required string EmailAddress { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public required string Signature { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    [JsonIgnore]
+    public string? TotpSecretkey { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public DateTime AddedWhen { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    [JsonIgnore]
+    public IEnumerable<EnvelopeReceiverDto>? EnvelopeReceivers { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public string? LastUsedName => EnvelopeReceivers?.LastOrDefault()?.Name;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public DateTime? TfaRegDeadline { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <returns></returns>
+    public override int GetHashCode()
+    {
+        return Id.GetHashCode();
+    }
+}

EnvelopeGenerator.Application/Common/Dto/SignatureDto.cs

@@ -0,0 +1,96 @@
+using EnvelopeGenerator.Domain.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.Common.Dto;
+
+/// <summary>
+/// Data Transfer Object representing a positioned element assigned to a document receiver.
+/// </summary>
+[ApiExplorerSettings(IgnoreApi = true)]
+public class SignatureDto : ISignature
+{
+    /// <summary>
+    /// Gets or sets the unique identifier of the element.
+    /// </summary>
+    public int Id { get; set; }
+
+    /// <summary>
+    /// Gets or sets the identifier of the associated document.
+    /// </summary>
+    public int DocumentId { get; set; }
+
+    /// <summary>
+    /// Gets or sets the identifier of the receiver.
+    /// </summary>
+    public int ReceiverId { get; set; }
+
+    /// <summary>
+    /// Gets or sets the type of the element.
+    /// </summary>
+    public int ElementType { get; set; }
+
+    /// <summary>
+    /// Gets or sets the X coordinate of the element.
+    /// </summary>
+    public double X { get; set; }
+
+    /// <summary>
+    /// Gets or sets the Y coordinate of the element.
+    /// </summary>
+    public double Y { get; set; }
+
+    /// <summary>
+    /// Gets or sets the width of the element.
+    /// </summary>
+    public double Width { get; set; }
+
+    /// <summary>
+    /// Gets or sets the height of the element.
+    /// </summary>
+    public double Height { get; set; }
+
+    /// <summary>
+    /// Gets or sets the page number where the element appears.
+    /// </summary>
+    public int Page { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the element is required.
+    /// </summary>
+    public bool Required { get; set; }
+
+    /// <summary>
+    /// Gets or sets the tooltip text for the element.
+    /// </summary>
+    public string? Tooltip { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether the element is read-only.
+    /// </summary>
+    public bool ReadOnly { get; set; }
+
+    /// <summary>
+    /// Gets or sets the annotation index for ordering or reference.
+    /// </summary>
+    public int AnnotationIndex { get; set; }
+
+    /// <summary>
+    /// Gets or sets the timestamp when the element was added.
+    /// </summary>
+    public DateTime AddedWhen { get; set; }
+
+    /// <summary>
+    /// Gets or sets the timestamp when the element was last changed, if applicable.
+    /// </summary>
+    public DateTime? ChangedWhen { get; set; }
+
+    /// <summary>
+    /// Gets or sets the top position of the element (in layout terms).
+    /// </summary>
+    public double Top => Y;
+
+    /// <summary>
+    /// Gets or sets the left position of the element (in layout terms).
+    /// </summary>
+    public double Left => X;
+}

EnvelopeGenerator.Application/Common/EnvelopeFlag.cs

@@ -0,0 +1,27 @@
+namespace EnvelopeGenerator.Application.Common;
+
+/// <summary>
+/// 
+/// </summary>
+public enum EnvelopeFlag
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    EnvelopeOrReceiverNonexists,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    NonDecodableEnvelopeReceiverId,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    WrongEnvelopeReceiverId,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    AccessCodeNull
+}

EnvelopeGenerator.Application/Common/Extensions/CacheExtensions.cs

@@ -0,0 +1,222 @@
+using Microsoft.Extensions.Caching.Distributed;
+
+namespace EnvelopeGenerator.Application.Common.Extensions;
+
+/// <summary>
+/// 
+/// </summary>
+public static class CacheExtensions
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="cache"></param>
+    /// <param name="key"></param>
+    /// <param name="value"></param>
+    /// <param name="options"></param>
+    /// <param name="cToken"></param>
+    /// <returns></returns>
+    public static Task SetLongAsync(this IDistributedCache cache, string key, long value, DistributedCacheEntryOptions? options = null, CancellationToken cToken = default)
+        => options is null
+            ? cache.SetAsync(key, BitConverter.GetBytes(value), token: cToken)
+            : cache.SetAsync(key, BitConverter.GetBytes(value), options: options, token: cToken);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="cache"></param>
+    /// <param name="key"></param>
+    /// <param name="cToken"></param>
+    /// <returns></returns>
+    public static async Task<long?> GetLongAsync(this IDistributedCache cache, string key, CancellationToken cToken = default)
+    {
+        var value = await cache.GetAsync(key, cToken);
+        return value is null ? null : BitConverter.ToInt64(value, 0);
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="cache"></param>
+    /// <param name="key"></param>
+    /// <param name="value"></param>
+    /// <param name="options"></param>
+    /// <param name="cToken"></param>
+    /// <returns></returns>
+    public static Task SetDateTimeAsync(this IDistributedCache cache, string key, DateTime value, DistributedCacheEntryOptions? options = null, CancellationToken cToken = default)
+        => cache.SetLongAsync(key: key, value: value.Ticks, options: options, cToken: cToken);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="cache"></param>
+    /// <param name="key"></param>
+    /// <param name="cToken"></param>
+    /// <returns></returns>
+    public static async Task<DateTime?> GetDateTimeAsync(this IDistributedCache cache, string key, CancellationToken cToken = default)
+    {
+        var value = await cache.GetAsync(key, cToken);
+        return value is null ? null : new(BitConverter.ToInt64(value, 0));
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="cache"></param>
+    /// <param name="key"></param>
+    /// <param name="value"></param>
+    /// <param name="options"></param>
+    /// <param name="cToken"></param>
+    /// <returns></returns>
+    public static Task SetTimeSpanAsync(this IDistributedCache cache, string key, TimeSpan value, DistributedCacheEntryOptions? options = null, CancellationToken cToken = default)
+        => cache.SetLongAsync(key: key, value: value.Ticks, options: options, cToken);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="cache"></param>
+    /// <param name="key"></param>
+    /// <param name="cToken"></param>
+    /// <returns></returns>
+    public static async Task<TimeSpan?> GetTimeSpanAsync(this IDistributedCache cache, string key, CancellationToken cToken = default)
+    {
+        var value = await cache.GetAsync(key, cToken);
+        return value is null ? null : new(BitConverter.ToInt64(value, 0));
+    }
+
+    //TODO: use code generator
+    #region GetOrSetAsync
+
+    #region string
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="cache"></param>
+    /// <param name="key"></param>
+    /// <param name="factory"></param>
+    /// <param name="options"></param>
+    /// <param name="cacheInBackground"></param>
+    /// <param name="cToken"></param>
+    /// <returns></returns>
+    public static async Task<string> GetOrSetAsync(this IDistributedCache cache, string key, Func<string> factory, DistributedCacheEntryOptions? options = null, bool cacheInBackground = false, CancellationToken cToken = default)
+    {
+        var value = await cache.GetStringAsync(key, cToken);
+        if (value is null)
+        {
+            // create new and save
+            value = factory();
+
+            Task CacheAsync() => options is null
+                    ? cache.SetStringAsync(key, value, cToken)
+                    : cache.SetStringAsync(key, value, options, cToken);
+
+            if (cacheInBackground)
+                _ = Task.Run(async () => await CacheAsync(), cToken);
+            else
+                await CacheAsync();
+        }
+
+        return value;
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="cache"></param>
+    /// <param name="key"></param>
+    /// <param name="factoryAsync"></param>
+    /// <param name="options"></param>
+    /// <param name="cacheInBackground"></param>
+    /// <param name="cToken"></param>
+    /// <returns></returns>
+    public static async Task<string> GetOrSetAsync(this IDistributedCache cache, string key, Func<Task<string>> factoryAsync, DistributedCacheEntryOptions? options = null, bool cacheInBackground = false, CancellationToken cToken = default)
+    {
+        var value = await cache.GetStringAsync(key, cToken);
+        if(value is null)
+        {
+            // create new and save
+            value = await factoryAsync();
+
+            Task CacheAsync() => options is null
+                ? cache.SetStringAsync(key: key, value: value, token: cToken)
+                : cache.SetStringAsync(key: key, value: value, options: options, token: cToken);
+
+            if (cacheInBackground)
+                _ = Task.Run(async () => await CacheAsync(), cToken);
+            else
+                await CacheAsync();
+        }
+
+        return value;
+    }
+    #endregion
+
+    #region DateTime
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="cache"></param>
+    /// <param name="key"></param>
+    /// <param name="factory"></param>
+    /// <param name="options"></param>
+    /// <param name="cacheInBackground"></param>
+    /// <param name="cToken"></param>
+    /// <returns></returns>
+    public static async Task<DateTime> GetOrSetAsync(this IDistributedCache cache, string key, Func<DateTime> factory, DistributedCacheEntryOptions? options = null, bool cacheInBackground = false, CancellationToken cToken = default)
+    {
+        if (await cache.GetDateTimeAsync(key, cToken) is DateTime dateTimeValue)
+            return dateTimeValue;
+        else
+        {
+            // create new and save
+            var newValue = factory();
+
+            Task CacheAsync() => options is null
+                    ? cache.SetDateTimeAsync(key, newValue, cToken: cToken)
+                    : cache.SetDateTimeAsync(key, newValue, options, cToken);
+
+            if (cacheInBackground)
+                _ = Task.Run(async () => await CacheAsync(), cToken);
+            else
+                await CacheAsync();
+
+            return newValue;
+        }
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="cache"></param>
+    /// <param name="key"></param>
+    /// <param name="factory"></param>
+    /// <param name="options"></param>
+    /// <param name="cacheInBackground"></param>
+    /// <param name="cToken"></param>
+    /// <returns></returns>
+    public static async Task<DateTime> GetOrSetAsync(this IDistributedCache cache, string key, Func<Task<DateTime>> factory, DistributedCacheEntryOptions? options = null, bool cacheInBackground = false, CancellationToken cToken = default)
+    {
+        if (await cache.GetDateTimeAsync(key, cToken) is DateTime dateTimeValue)
+            return dateTimeValue;
+        else
+        {
+            // create new and save
+            var newValue = await factory();
+
+            Task CacheAsync() => options is null
+                    ? cache.SetDateTimeAsync(key, newValue, cToken: cToken)
+                    : cache.SetDateTimeAsync(key, newValue, options, cToken);
+
+            if (cacheInBackground)
+                _ = Task.Run(async () => await CacheAsync(), cToken);
+            else
+                await CacheAsync();
+
+            return newValue;
+        }
+    }
+    #endregion
+
+    #endregion
+}

EnvelopeGenerator.Application/Common/Extensions/DecodingExtensions.cs

@@ -0,0 +1,182 @@
+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;
+}

EnvelopeGenerator.Application/Common/Extensions/EncodingExtensions.cs

@@ -0,0 +1,38 @@
+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;
+    }
+}

EnvelopeGenerator.Application/Common/Extensions/JsonExtensions.cs

@@ -0,0 +1,18 @@
+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);
+}

EnvelopeGenerator.Application/Common/Extensions/LoggerExtensions.cs

@@ -1,7 +1,7 @@
 using Microsoft.Extensions.Logging;
 using System.Text;
 
-namespace EnvelopeGenerator.Extensions
+namespace EnvelopeGenerator.Application.Common.Extensions
 {
     public static class LoggerExtensions
     {

EnvelopeGenerator.Application/Common/Extensions/MappingExtensions.cs

@@ -0,0 +1,27 @@
+using EnvelopeGenerator.Application.Common.Dto.Messaging;
+
+namespace EnvelopeGenerator.Application.Common.Extensions;
+
+/// <summary>
+/// Provides extension methods for common mapping and conversion operations.
+/// </summary>
+public static class MappingExtensions
+{
+    /// <summary>
+    /// Determines whether the response indicates a successful "OK" message status.
+    /// </summary>
+    /// <param name="gtxMessagingResponse">The response object to evaluate.</param>
+    /// <returns><see langword="true"/> if the response contains a "message-status" key with a value of "ok"  (case-insensitive);
+    /// otherwise, <see langword="false"/>.</returns>
+    public static bool Ok(this GtxMessagingResponse gtxMessagingResponse)
+        => gtxMessagingResponse.TryGetValue("message-status", out var status)
+        && status?.ToString()?.ToLower() == "ok";
+
+    /// <summary>
+    /// Converts the specified byte array to its equivalent string representation encoded in base-64.
+    /// </summary>
+    /// <param name="bytes">The byte array to encode.</param>
+    /// <returns>A base-64 encoded string representation of the input byte array.</returns>
+    public static string ToBase64String(this byte[] bytes)
+        => Convert.ToBase64String(bytes);
+}

EnvelopeGenerator.Application/Common/Extensions/MemoryCacheExtensions.cs

@@ -0,0 +1,42 @@
+using EnvelopeGenerator.Application.Common.Extensions;
+using Microsoft.Extensions.Caching.Memory;
+
+namespace EnvelopeGenerator.Application.Common.Extensions;
+
+/// <summary>
+/// 
+/// </summary>
+public static class MemoryCacheExtensions
+{
+    private static readonly Guid BaseId = Guid.NewGuid();
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <typeparam name="TEnum"></typeparam>
+    /// <param name="memoryCache"></param>
+    /// <param name="key"></param>
+    /// <param name="ignores"></param>
+    /// <returns></returns>
+    /// <exception cref="InvalidOperationException"></exception>
+    public static IDictionary<string, int> GetEnumAsDictionary<TEnum>(this IMemoryCache memoryCache, string key = "", params object[] ignores)
+        where TEnum : Enum
+        => memoryCache.GetOrCreate(BaseId + typeof(TEnum).FullName + key, _ =>
+        {
+            var mergedIgnores = new List<TEnum>();
+
+            foreach (var ignore in ignores)
+            {
+                if (ignore is IEnumerable<TEnum> ignoreList)
+                    mergedIgnores.AddRange(ignoreList);
+                else if (ignore is TEnum ignoreVal)
+                    mergedIgnores.Add(ignoreVal);
+            }
+
+            return Enum.GetValues(typeof(TEnum))
+                   .Cast<TEnum>()
+                   .Where(e => !mergedIgnores.Contains(e))
+                   .ToDictionary(e => e.ToString(), e => Convert.ToInt32(e));
+        })
+           ?? throw new InvalidOperationException($"Failed to cache or retrieve enum dictionary for type '{typeof(TEnum).FullName}'.");
+}

EnvelopeGenerator.Application/Common/Extensions/QueryExtensions.cs

@@ -0,0 +1,125 @@
+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);
+}

EnvelopeGenerator.Application/Common/Extensions/StringExtension.cs

@@ -0,0 +1,30 @@
+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);
+}

EnvelopeGenerator.Application/Common/Extensions/TaskExtensions.cs

@@ -0,0 +1,78 @@
+using DigitalData.Core.Exceptions;
+
+namespace EnvelopeGenerator.Application.Common.Extensions;
+
+/// <summary>
+/// Extension methods for tasks
+/// </summary>
+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>
+    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>
+    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>
+    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>
+public static class Exceptions
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public static NotFoundException NotFound() => new();
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <returns></returns>
+    public static BadRequestException BadRequest() => new();
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <returns></returns>
+    public static ForbiddenException Forbidden() => new();
+}

EnvelopeGenerator.Application/Common/Extensions/XSSExtensions.cs

@@ -2,7 +2,7 @@
 using Microsoft.Extensions.Localization;
 using System.Text.Encodings.Web;
 
-namespace EnvelopeGenerator.Extensions
+namespace EnvelopeGenerator.Application.Common.Extensions
 {
     public static class XSSExtensions
     {

EnvelopeGenerator.Application/Common/Interfaces/Repositories/IConfigRepository.cs

@@ -0,0 +1,17 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.Repositories;
+
+/// <summary>
+/// 
+/// </summary>
+[Obsolete("Use IRepository")]
+public interface IConfigRepository : ICRUDRepository<Config, int>
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <returns></returns>
+    Task<Config?> ReadFirstAsync();
+}

EnvelopeGenerator.Application/Common/Interfaces/Repositories/IDocumentReceiverElementRepository.cs

@@ -0,0 +1,11 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.Repositories;
+/// <summary>
+/// 
+/// </summary>
+[Obsolete("Use IRepository")]
+public interface IDocumentReceiverElementRepository : ICRUDRepository<Signature, int>
+{
+}

EnvelopeGenerator.Application/Common/Interfaces/Repositories/IDocumentStatusRepository.cs

@@ -0,0 +1,12 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.Repositories;
+
+/// <summary>
+/// 
+/// </summary>
+[Obsolete("Use IRepository")]
+public interface IDocumentStatusRepository : ICRUDRepository<DocumentStatus, int>
+{
+}

EnvelopeGenerator.Application/Common/Interfaces/Repositories/IEmailTemplateRepository.cs

@@ -0,0 +1,19 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Domain.Constants;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.Repositories;
+
+/// <summary>
+/// 
+/// </summary>
+[Obsolete("Use IRepository")]
+public interface IEmailTemplateRepository : ICRUDRepository<EmailTemplate, int>
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="type"></param>
+    /// <returns></returns>
+    Task<EmailTemplate?> ReadByNameAsync(EmailTemplateType type);
+}

EnvelopeGenerator.Application/Common/Interfaces/Repositories/IEnvelopeDocumentRepository.cs

@@ -0,0 +1,12 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.Repositories;
+
+/// <summary>
+/// 
+/// </summary>
+[Obsolete("Use IRepository")]
+public interface IEnvelopeDocumentRepository : ICRUDRepository<Document, int>
+{
+}

EnvelopeGenerator.Application/Common/Interfaces/Repositories/IEnvelopeHistoryRepository.cs

@@ -0,0 +1,32 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Domain.Constants;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.Repositories;
+
+/// <summary>
+/// 
+/// </summary>
+[Obsolete("Use IRepository")]
+public interface IEnvelopeHistoryRepository : ICRUDRepository<History, long>
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="envelopeId"></param>
+    /// <param name="userReference"></param>
+    /// <param name="status"></param>
+    /// <returns></returns>
+    Task<int> CountAsync(int? envelopeId = null, string? userReference = null, EnvelopeStatus? status = null);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="envelopeId"></param>
+    /// <param name="userReference"></param>
+    /// <param name="status"></param>
+    /// <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);
+}

EnvelopeGenerator.Application/Common/Interfaces/Repositories/IEnvelopeReceiverReadOnlyRepository.cs

@@ -0,0 +1,12 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.Repositories;
+
+/// <summary>
+/// 
+/// </summary>
+[Obsolete("Use IRepository")]
+public interface IEnvelopeReceiverReadOnlyRepository : ICRUDRepository<EnvelopeReceiverReadOnly, long>
+{
+}

EnvelopeGenerator.Application/Common/Interfaces/Repositories/IEnvelopeReceiverRepository.cs

@@ -0,0 +1,98 @@
+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;
+
+/// <summary>
+/// 
+/// </summary>
+[Obsolete("Use IRepository")]
+public interface IEnvelopeReceiverRepository : ICRUDRepository<EnvelopeReceiver, (int Envelope, int Receiver)>
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="uuid"></param>
+    /// <param name="withEnvelope"></param>
+    /// <param name="withReceiver"></param>
+    /// <param name="readOnly"></param>
+    /// <returns></returns>
+    Task<IEnumerable<EnvelopeReceiver>> ReadByUuidAsync(string uuid, bool withEnvelope = true, bool withReceiver = false, bool readOnly = true);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="signature"></param>
+    /// <param name="withEnvelope"></param>
+    /// <param name="withReceiver"></param>
+    /// <param name="readOnly"></param>
+    /// <returns></returns>
+    Task<IEnumerable<EnvelopeReceiver>> ReadBySignatureAsync(string signature, bool withEnvelope = false, bool withReceiver = true, bool readOnly = true);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="uuid"></param>
+    /// <param name="signature"></param>
+    /// <param name="withEnvelope"></param>
+    /// <param name="withReceiver"></param>
+    /// <param name="readOnly"></param>
+    /// <returns></returns>
+    Task<EnvelopeReceiver?> ReadByUuidSignatureAsync(string uuid, string signature, bool withEnvelope = true, bool withReceiver = true, bool readOnly = true);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="uuid"></param>
+    /// <param name="signature"></param>
+    /// <param name="readOnly"></param>
+    /// <returns></returns>
+    Task<string?> ReadAccessCodeAsync(string uuid, string signature, bool readOnly = true);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="uuid"></param>
+    /// <param name="signature"></param>
+    /// <returns></returns>
+    Task<int> CountAsync(string uuid, string signature);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="envelopeId"></param>
+    /// <param name="receiverId"></param>
+    /// <param name="readOnly"></param>
+    /// <returns></returns>
+    Task<EnvelopeReceiver?> ReadByIdAsync(int envelopeId, int receiverId, bool readOnly = true);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="envelopeId"></param>
+    /// <param name="receiverId"></param>
+    /// <param name="readOnly"></param>
+    /// <returns></returns>
+    Task<string?> ReadAccessCodeByIdAsync(int envelopeId, int receiverId, bool readOnly = true);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="username"></param>
+    /// <param name="min_status"></param>
+    /// <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);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="email"></param>
+    /// <param name="id"></param>
+    /// <param name="signature"></param>
+    /// <returns></returns>
+    Task<EnvelopeReceiver?> ReadLastByReceiverAsync(string? email = null, int? id = null, string? signature = null);
+}

EnvelopeGenerator.Application/Common/Interfaces/Repositories/IEnvelopeRepository.cs

@@ -0,0 +1,43 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Domain.Constants;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.Repositories;
+
+/// <summary>
+/// 
+/// </summary>
+[Obsolete("Use IRepository")]
+public interface IEnvelopeRepository : ICRUDRepository<Envelope, int>
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="documents"></param>
+    /// <param name="history"></param>
+    /// <param name="documentReceiverElement"></param>
+    /// <returns></returns>
+    Task<IEnumerable<Envelope>> ReadAllWithAsync(bool documents = false, bool history = false, bool documentReceiverElement = false);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="uuid"></param>
+    /// <param name="withDocuments"></param>
+    /// <param name="withHistory"></param>
+    /// <param name="withDocumentReceiverElement"></param>
+    /// <param name="withUser"></param>
+    /// <param name="withAll"></param>
+    /// <returns></returns>
+    Task<Envelope?> ReadByUuidAsync(string uuid, bool withDocuments = false, bool withHistory = false, bool withDocumentReceiverElement = false, bool withUser = false, bool withAll = false);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="userId"></param>
+    /// <param name="min_status"></param>
+    /// <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);
+}

EnvelopeGenerator.Application/Common/Interfaces/Repositories/IEnvelopeTypeRepository.cs

@@ -0,0 +1,12 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.Repositories;
+
+/// <summary>
+/// 
+/// </summary>
+[Obsolete("Use IRepository")]
+public interface IEnvelopeTypeRepository : ICRUDRepository<EnvelopeType, int>
+{
+}

EnvelopeGenerator.Application/Common/Interfaces/Repositories/IReceiverRepository.cs

@@ -0,0 +1,19 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.Repositories;
+
+/// <summary>
+/// 
+/// </summary>
+[Obsolete("Use IRepository")]
+public interface IReceiverRepository : ICRUDRepository<Receiver, int>
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="emailAddress"></param>
+    /// <param name="signature"></param>
+    /// <returns></returns>
+    Task<Receiver?> ReadByAsync(string? emailAddress = null, string? signature = null);
+}

EnvelopeGenerator.Application/Common/Interfaces/SQLExecutor/IDocumentExecutor.cs

@@ -0,0 +1,18 @@
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.SQLExecutor;
+
+/// <summary>
+/// 
+/// </summary>
+public interface IDocumentExecutor
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="base64"></param>
+    /// <param name="envelope_uuid"></param>
+    /// <param name="cancellation"></param>
+    /// <returns></returns>
+    Task<Document> CreateDocumentAsync(string base64, string envelope_uuid, CancellationToken cancellation = default);
+}

EnvelopeGenerator.Application/Common/Interfaces/SQLExecutor/IEnvelopeExecutor.cs

@@ -0,0 +1,21 @@
+using Dapper;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.SQLExecutor;
+
+/// <summary>
+/// 
+/// </summary>
+public interface IEnvelopeExecutor : ISQLExecutor
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="userId"></param>
+    /// <param name="title"></param>
+    /// <param name="message"></param>
+    /// <param name="tfaEnabled"></param>
+    /// <param name="cancellation"></param>
+    /// <returns></returns>
+    Task<Envelope> CreateEnvelopeAsync(int userId, string title = "", string message = "", bool tfaEnabled = false, CancellationToken cancellation = default);
+}

EnvelopeGenerator.Application/Common/Interfaces/SQLExecutor/IEnvelopeReceiverExecutor.cs

@@ -0,0 +1,20 @@
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.SQLExecutor;
+
+/// <summary>
+/// 
+/// </summary>
+public interface IEnvelopeReceiverExecutor
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="envelope_uuid"></param>
+    /// <param name="emailAddress"></param>
+    /// <param name="salutation"></param>
+    /// <param name="phone"></param>
+    /// <param name="cancellation"></param>
+    /// <returns></returns>
+    Task<EnvelopeReceiver?> AddEnvelopeReceiverAsync(string envelope_uuid, string emailAddress, string? salutation = null, string? phone = null, CancellationToken cancellation = default);
+}

EnvelopeGenerator.Application/Common/Interfaces/SQLExecutor/IQuery.cs

@@ -0,0 +1,70 @@
+namespace EnvelopeGenerator.Application.Common.Interfaces.SQLExecutor;
+
+/// <summary>
+/// Provides methods for executing common queries on a given entity type.
+/// This interface abstracts away the direct usage of ORM libraries (such as Entity Framework) for querying data
+/// and provides asynchronous and synchronous operations for querying a collection or single entity.
+/// </summary>
+/// <typeparam name="TEntity">The type of the entity being queried.</typeparam>
+public interface IQuery<TEntity>
+{
+    /// <summary>
+    /// Asynchronously retrieves the first entity or a default value if no entity is found.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous operation. The task result contains the entity or a default value.</returns>
+    public Task<TEntity?> FirstOrDefaultAsync();
+
+    /// <summary>
+    /// Asynchronously retrieves a single entity or a default value if no entity is found.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous operation. The task result contains the entity or a default value.</returns>
+    public Task<TEntity?> SingleOrDefaultAsync();
+
+    /// <summary>
+    /// Asynchronously retrieves a list of entities.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous operation. The task result contains the list of entities.</returns>
+    public Task<IEnumerable<TEntity>> ToListAsync();
+
+    /// <summary>
+    /// Asynchronously retrieves the first entity. Throws an exception if no entity is found.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous operation. The task result contains the first entity.</returns>
+    public Task<TEntity> FirstAsync();
+
+    /// <summary>
+    /// Asynchronously retrieves a single entity. Throws an exception if no entity is found.
+    /// </summary>
+    /// <returns>A task that represents the asynchronous operation. The task result contains the single entity.</returns>
+    public Task<TEntity> SingleAsync();
+
+    /// <summary>
+    /// Synchronously retrieves the first entity or a default value if no entity is found.
+    /// </summary>
+    /// <returns>The first entity or a default value.</returns>
+    public TEntity? FirstOrDefault();
+
+    /// <summary>
+    /// Synchronously retrieves a single entity or a default value if no entity is found.
+    /// </summary>
+    /// <returns>The single entity or a default value.</returns>
+    public TEntity? SingleOrDefault();
+
+    /// <summary>
+    /// Synchronously retrieves a list of entities.
+    /// </summary>
+    /// <returns>The list of entities.</returns>
+    public IEnumerable<TEntity> ToList();
+
+    /// <summary>
+    /// Synchronously retrieves the first entity. Throws an exception if no entity is found.
+    /// </summary>
+    /// <returns>The first entity.</returns>
+    public TEntity First();
+
+    /// <summary>
+    /// Synchronously retrieves a single entity. Throws an exception if no entity is found.
+    /// </summary>
+    /// <returns>The single entity.</returns>
+    public TEntity Single();
+}

EnvelopeGenerator.Application/Common/Interfaces/SQLExecutor/ISQL.cs

@@ -0,0 +1,20 @@
+namespace EnvelopeGenerator.Application.Common.Interfaces.SQLExecutor;
+
+/// <summary>
+/// Represents a raw SQL query contract.
+/// </summary>
+public interface ISQL
+{
+    /// <summary>
+    /// Gets the raw SQL query string.
+    /// </summary>
+    string Raw { get; }
+}
+
+/// <summary>
+/// Represents a typed SQL query contract for a specific entity.
+/// </summary>
+/// <typeparam name="TEntity">The type of the entity associated with the SQL query.</typeparam>
+public interface ISQL<TEntity> : ISQL
+{
+}

EnvelopeGenerator.Application/Common/Interfaces/SQLExecutor/ISQLExecutor.cs

@@ -0,0 +1,27 @@
+namespace EnvelopeGenerator.Application.Common.Interfaces.SQLExecutor;
+
+/// <summary>
+/// Defines methods for executing raw SQL queries or custom SQL query classes and returning query executors for further operations.
+/// Provides abstraction for raw SQL execution as well as mapping the results to <typeparamref name="TEntity"/> objects.
+/// </summary>
+/// <typeparam name="TEntity">The entity type to which the SQL query results will be mapped.</typeparam>
+public interface ISQLExecutor<TEntity>: ISQLExecutor
+{
+    /// <summary>
+    /// Executes a raw SQL query and returns an <see cref="IQuery{TEntity}"/> for further querying operations on the result.
+    /// </summary>
+    /// <param name="sql">The raw SQL query to execute.</param>
+    /// <param name="cancellation">Optional cancellation token for the operation.</param>
+    /// <param name="parameters">Optional parameters for the SQL query.</param>
+    /// <returns>An <see cref="IQuery{TEntity}"/> instance for further query operations on the result.</returns>
+    IQuery<TEntity> Execute(string sql, CancellationToken cancellation = default, params object[] parameters);
+
+    /// <summary>
+    /// Executes a custom SQL query defined by a class that implements <see cref="ISQL{TEntity}"/> and returns an <see cref="IQuery{TEntity}"/> for further querying operations on the result.
+    /// </summary>
+    /// <typeparam name="TSQL">The type of the custom SQL query class implementing <see cref="ISQL{TEntity}"/>.</typeparam>
+    /// <param name="cancellation">Optional cancellation token for the operation.</param>
+    /// <param name="parameters">Optional parameters for the SQL query.</param>
+    /// <returns>An <see cref="IQuery{TEntity}"/> instance for further query operations on the result.</returns>
+    IQuery<TEntity> Execute<TSQL>(CancellationToken cancellation = default, params object[] parameters) where TSQL : ISQL<TEntity>;
+}

EnvelopeGenerator.Application/Common/Interfaces/SQLExecutor/ISQLExecutorBaseEntity.cs

@@ -0,0 +1,29 @@
+using Dapper;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.SQLExecutor;
+
+/// <summary>
+/// 
+/// </summary>
+public interface ISQLExecutor
+{
+    /// <summary>
+    /// Executes a raw SQL query and returns an <see cref="IQuery{TEntity}"/> for further querying operations on the result.
+    /// </summary>
+    /// <typeparam name="TEntity">The entity type to which the SQL query results will be mapped.</typeparam>
+    /// <param name="sql">The raw SQL query to execute.</param>
+    /// <param name="parameters">Parameters for the SQL query.</param>
+    /// <param name="cancellation">Optional cancellation token for the operation.</param>
+    /// <returns>An <see cref="IQuery{TEntity}"/> instance for further query operations on the result.</returns>
+    Task<IEnumerable<TEntity>> Execute<TEntity>(string sql, DynamicParameters parameters, CancellationToken cancellation = default);
+
+    /// <summary>
+    /// Executes a custom SQL query defined by a class that implements <see cref="ISQL{TEntity}"/> and returns an <see cref="IQuery{TEntity}"/> for further querying operations on the result.
+    /// </summary>
+    /// <typeparam name="TEntity">The entity type to which the SQL query results will be mapped.</typeparam>
+    /// <typeparam name="TSQL">The type of the custom SQL query class implementing <see cref="ISQL{TEntity}"/>.</typeparam>
+    /// <param name="parameters">Parameters for the SQL query.</param>
+    /// <param name="cancellation">Optional cancellation token for the operation.</param>
+    /// <returns>An <see cref="IQuery{TEntity}"/> instance for further query operations on the result.</returns>
+    Task<IEnumerable<TEntity>> Execute<TEntity, TSQL>(DynamicParameters parameters, CancellationToken cancellation = default) where TSQL : ISQL;
+}

EnvelopeGenerator.Application/Common/Interfaces/Services/IAuthenticator.cs

@@ -0,0 +1,63 @@
+using OtpNet;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+
+/// <summary>
+/// 
+/// </summary>
+public interface IAuthenticator
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="length"></param>
+    /// <returns></returns>
+    string GenerateCode(int length);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="length"></param>
+    /// <returns></returns>
+    string GenerateTotpSecretKey(int? length = null);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="userEmail"></param>
+    /// <param name="secretKey"></param>
+    /// <param name="issuer"></param>
+    /// <param name="totpUrlFormat"></param>
+    /// <param name="pixelsPerModule"></param>
+    /// <returns></returns>
+    byte[] GenerateTotpQrCode(string userEmail, string secretKey, string? issuer = null, string? totpUrlFormat = null, int? pixelsPerModule = null);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="userEmail"></param>
+    /// <param name="length"></param>
+    /// <param name="issuer"></param>
+    /// <param name="totpUrlFormat"></param>
+    /// <param name="pixelsPerModule"></param>
+    /// <returns></returns>
+    byte[] GenerateTotpQrCode(string userEmail, int? length = null, string? issuer = null, string? totpUrlFormat = null, int? pixelsPerModule = null);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="secretKey"></param>
+    /// <param name="step"></param>
+    /// <returns></returns>
+    string GenerateTotp(string secretKey, int step = 30);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="totpCode"></param>
+    /// <param name="secretKey"></param>
+    /// <param name="step"></param>
+    /// <param name="window"></param>
+    /// <returns></returns>
+    bool VerifyTotp(string totpCode, string secretKey, int step = 30, VerificationWindow? window = null);
+}

EnvelopeGenerator.Application/Common/Interfaces/Services/IConfigService.cs

@@ -0,0 +1,31 @@
+using DigitalData.Core.Abstraction.Application;
+using DigitalData.Core.Abstraction.Application.DTO;
+using EnvelopeGenerator.Application.Common.Dto;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+
+/// <summary>
+/// 
+/// </summary>
+[Obsolete("Use MediatR")]
+public interface IConfigService : IReadService<ConfigDto, Config, int>
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <returns></returns>
+    Task<DataResult<ConfigDto>> ReadFirstAsync();
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <returns></returns>
+    Task<ConfigDto> ReadDefaultAsync();
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <returns></returns>
+    Task<string> ReadDefaultSignatureHost();
+}

EnvelopeGenerator.Application/Common/Interfaces/Services/IDocumentReceiverElementService.cs

@@ -0,0 +1,13 @@
+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 IDocumentReceiverElementService : IBasicCRUDService<SignatureDto, Signature, int>
+{
+}

EnvelopeGenerator.Application/Common/Interfaces/Services/IDocumentStatusService.cs

@@ -0,0 +1,12 @@
+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 IDocumentStatusService : IBasicCRUDService<DocumentStatusDto, DocumentStatus, int>
+{
+}

EnvelopeGenerator.Application/Common/Interfaces/Services/IEmailTemplateService.cs

@@ -0,0 +1,21 @@
+using DigitalData.Core.Abstraction.Application;
+using DigitalData.Core.Abstraction.Application.DTO;
+using EnvelopeGenerator.Application.Common.Dto;
+using EnvelopeGenerator.Domain.Constants;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+
+/// <summary>
+/// 
+/// </summary>
+[Obsolete("Use MediatR")]
+public interface IEmailTemplateService : IBasicCRUDService<EmailTemplateDto, EmailTemplate, int>
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="type"></param>
+    /// <returns></returns>
+    Task<DataResult<EmailTemplateDto>> ReadByNameAsync(EmailTemplateType type);
+}

EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeDocumentService.cs

@@ -0,0 +1,13 @@
+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>
+{
+}

EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeHistoryService.cs

@@ -0,0 +1,85 @@
+using DigitalData.Core.Abstraction.Application;
+using DigitalData.Core.Abstraction.Application.DTO;
+using EnvelopeGenerator.Application.Common.Dto.History;
+using EnvelopeGenerator.Application.Common.Dto.Receiver;
+using EnvelopeGenerator.Domain.Constants;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+
+/// <summary>
+/// 
+/// </summary>
+[Obsolete("Use MediatR")]
+public interface IEnvelopeHistoryService : ICRUDService<HistoryCreateDto, HistoryDto, History, long>
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="envelopeId"></param>
+    /// <param name="userReference"></param>
+    /// <param name="status"></param>
+    /// <returns></returns>
+    Task<int> CountAsync(int? envelopeId = null, string? userReference = null, EnvelopeStatus? status = null);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="envelopeId"></param>
+    /// <param name="userReference"></param>
+    /// <returns></returns>
+    Task<bool> AccessCodeAlreadyRequested(int envelopeId, string userReference);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="envelopeId"></param>
+    /// <param name="userReference"></param>
+    /// <returns></returns>
+    Task<bool> IsSigned(int envelopeId, string userReference);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="envelopeId"></param>
+    /// <param name="userReference"></param>
+    /// <returns></returns>
+    Task<bool> IsRejected(int envelopeId, string? userReference = null);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="envelopeId"></param>
+    /// <param name="userReference"></param>
+    /// <param name="referenceType"></param>
+    /// <param name="status"></param>
+    /// <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);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="envelopeId"></param>
+    /// <param name="userReference"></param>
+    /// <returns></returns>
+    Task<IEnumerable<HistoryDto>> ReadRejectedAsync(int envelopeId, string? userReference = null);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="envelopeId"></param>
+    /// <returns></returns>
+    Task<IEnumerable<ReceiverDto>> ReadRejectingReceivers(int envelopeId);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="envelopeId"></param>
+    /// <param name="userReference"></param>
+    /// <param name="status"></param>
+    /// <param name="comment"></param>
+    /// <returns></returns>
+    Task<DataResult<long>> RecordAsync(int envelopeId, string userReference, EnvelopeStatus status, string? comment = null);
+}

EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeMailService.cs

@@ -0,0 +1,38 @@
+using DigitalData.Core.Abstraction.Application.DTO;
+using DigitalData.EmailProfilerDispatcher.Abstraction.Contracts;
+using EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiver;
+using EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiverReadOnly;
+using EnvelopeGenerator.Domain.Constants;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+
+/// <summary>
+/// 
+/// </summary>
+[Obsolete("Use MediatR")]
+public interface IEnvelopeMailService : IEmailOutService
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="envelopeReceiverDto"></param>
+    /// <param name="tempType"></param>
+    /// <param name="optionalPlaceholders"></param>
+    /// <returns></returns>
+    Task<DataResult<int>> SendAsync(EnvelopeReceiverDto envelopeReceiverDto, EmailTemplateType tempType, Dictionary<string, object>? optionalPlaceholders = null);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="dto"></param>
+    /// <param name="optionalPlaceholders"></param>
+    /// <returns></returns>
+    Task<DataResult<int>> SendAsync(EnvelopeReceiverReadOnlyDto dto, Dictionary<string, object>? optionalPlaceholders = null);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="envelopeReceiverDto"></param>
+    /// <returns></returns>
+    Task<DataResult<int>> SendAccessCodeAsync(EnvelopeReceiverDto envelopeReceiverDto);
+}

EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeReceiverReadOnlyService.cs

@@ -0,0 +1,13 @@
+using DigitalData.Core.Abstraction.Application;
+using EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiverReadOnly;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+
+/// <summary>
+/// 
+/// </summary>
+[Obsolete("Use MediatR")]
+public interface IEnvelopeReceiverReadOnlyService : ICRUDService<EnvelopeReceiverReadOnlyCreateDto, EnvelopeReceiverReadOnlyDto, EnvelopeReceiverReadOnly, long>
+{
+}

EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeReceiverService.cs

@@ -0,0 +1,151 @@
+using CommandDotNet;
+using DigitalData.Core.Abstraction.Application;
+using DigitalData.Core.Abstraction.Application.DTO;
+using EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiver;
+using EnvelopeGenerator.Application.Common.Dto.Messaging;
+using EnvelopeGenerator.Application.Envelopes;
+using EnvelopeGenerator.Application.Envelopes.Queries;
+using EnvelopeGenerator.Application.Receivers.Queries;
+using EnvelopeGenerator.Domain;
+using EnvelopeGenerator.Domain.Constants;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+
+/// <summary>
+/// 
+/// </summary>
+[Obsolete("Use MediatR")]
+public interface IEnvelopeReceiverService : IBasicCRUDService<EnvelopeReceiverDto, EnvelopeReceiver, (int Envelope, int Receiver)>
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="uuid"></param>
+    /// <param name="withEnvelope"></param>
+    /// <param name="withReceiver"></param>
+    /// <param name="readOnly"></param>
+    /// <returns></returns>
+
+    Task<DataResult<IEnumerable<EnvelopeReceiverDto>>> ReadByUuidAsync(string uuid, bool withEnvelope = true, bool withReceiver = false, bool readOnly = true);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="uuid"></param>
+    /// <param name="withEnvelope"></param>
+    /// <param name="withReceiver"></param>
+    /// <returns></returns>
+    Task<DataResult<IEnumerable<string?>>> ReadAccessCodeByUuidAsync(string uuid, bool withEnvelope = false, bool withReceiver = true);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="signature"></param>
+    /// <param name="withEnvelope"></param>
+    /// <param name="withReceiver"></param>
+    /// <param name="readOnly"></param>
+    /// <returns></returns>
+    Task<DataResult<IEnumerable<EnvelopeReceiverDto>>> ReadBySignatureAsync(string signature, bool withEnvelope = false, bool withReceiver = true, bool readOnly = true);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="uuid"></param>
+    /// <param name="signature"></param>
+    /// <param name="withEnvelope"></param>
+    /// <param name="withReceiver"></param>
+    /// <param name="readOnly"></param>
+    /// <returns></returns>
+    Task<DataResult<EnvelopeReceiverDto>> ReadByUuidSignatureAsync(string uuid, string signature, bool withEnvelope = true, bool withReceiver = true, bool readOnly = true);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="uuid"></param>
+    /// <param name="signature"></param>
+    /// <param name="withEnvelope"></param>
+    /// <param name="withReceiver"></param>
+    /// <param name="readOnly"></param>
+    /// <returns></returns>
+    Task<DataResult<EnvelopeReceiverSecretDto>> ReadWithSecretByUuidSignatureAsync(string uuid, string signature, bool withEnvelope = true, bool withReceiver = true, bool readOnly = true);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="envelopeReceiverId"></param>
+    /// <param name="withEnvelope"></param>
+    /// <param name="withReceiver"></param>
+    /// <param name="readOnly"></param>
+    /// <returns></returns>
+    Task<DataResult<EnvelopeReceiverDto>> ReadByEnvelopeReceiverIdAsync(string envelopeReceiverId, bool withEnvelope = true, bool withReceiver = true, bool readOnly = true);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="envelopeId"></param>
+    /// <param name="receiverId"></param>
+    /// <returns></returns>
+    Task<DataResult<string>> ReadAccessCodeByIdAsync(int envelopeId, int receiverId);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="uuid"></param>
+    /// <param name="signature"></param>
+    /// <param name="accessCode"></param>
+    /// <returns></returns>
+    Task<DataResult<bool>> VerifyAccessCodeAsync(string uuid, string signature, string accessCode);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="envelopeReceiverId"></param>
+    /// <param name="accessCode"></param>
+    /// <returns></returns>
+    [Command("verify-access-code-async-by-id")]
+    Task<DataResult<bool>> VerifyAccessCodeAsync(string envelopeReceiverId, string accessCode);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="envelopeReceiverId"></param>
+    /// <returns></returns>
+    Task<DataResult<bool>> IsExisting(string envelopeReceiverId);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="username"></param>
+    /// <param name="min_status"></param>
+    /// <param name="max_status"></param>
+    /// <param name="envelopeQuery"></param>
+    /// <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);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="mail"></param>
+    /// <param name="id"></param>
+    /// <param name="signature"></param>
+    /// <returns></returns>
+    Task<DataResult<string>> ReadLastUsedReceiverNameByMailAsync(string? mail = null, int? id = null, string? signature = null);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="envelopeReceiverId"></param>
+    /// <param name="message"></param>
+    /// <returns></returns>
+    Task<DataResult<SmsResponse>> SendSmsAsync(string envelopeReceiverId, string message);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="uuid"></param>
+    /// <returns></returns>
+    Task<DataResult<IEnumerable<EnvelopeReceiverSecretDto>>> ReadWithSecretByUuidAsync(string uuid);
+}

EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeService.cs

@@ -0,0 +1,45 @@
+using DigitalData.Core.Abstraction.Application;
+using DigitalData.Core.Abstraction.Application.DTO;
+using EnvelopeGenerator.Application.Common.Dto;
+using EnvelopeGenerator.Domain.Constants;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+
+/// <summary>
+/// 
+/// </summary>
+[Obsolete("Use MediatR")]
+public interface IEnvelopeService : IBasicCRUDService<EnvelopeDto, Envelope, int>
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="documents"></param>
+    /// <param name="history"></param>
+    /// <param name="documentReceiverElement"></param>
+    /// <returns></returns>
+    Task<DataResult<IEnumerable<EnvelopeDto>>> ReadAllWithAsync(bool documents = false, bool history = false, bool documentReceiverElement = false);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="uuid"></param>
+    /// <param name="withDocuments"></param>
+    /// <param name="withHistory"></param>
+    /// <param name="withDocumentReceiverElement"></param>
+    /// <param name="withUser"></param>
+    /// <param name="withAll"></param>
+    /// <returns></returns>
+    Task<DataResult<EnvelopeDto>> ReadByUuidAsync(string uuid, bool withDocuments = false, bool withHistory = false, bool withDocumentReceiverElement = false, bool withUser = false, bool withAll = false);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="userId"></param>
+    /// <param name="min_status"></param>
+    /// <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);
+}

EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeSmsHandler.cs

@@ -1,8 +1,11 @@
-using EnvelopeGenerator.Application.DTOs.EnvelopeReceiver;
-using EnvelopeGenerator.Application.DTOs.Messaging;
+using EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiver;
+using EnvelopeGenerator.Application.Common.Dto.Messaging;
 
-namespace EnvelopeGenerator.Application.Contracts.Services;
+namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
 
+/// <summary>
+/// 
+/// </summary>
 public interface IEnvelopeSmsHandler
 {
     /// <summary>
@@ -13,5 +16,11 @@ public interface IEnvelopeSmsHandler
     /// <returns></returns>
     Task<(SmsResponse? SmsResponse, DateTime Expiration)> SendTotpAsync(EnvelopeReceiverSecretDto er_secret, CancellationToken cToken = default);
 
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="totpCode"></param>
+    /// <param name="secretKey"></param>
+    /// <returns></returns>
     bool VerifyTotp(string totpCode, string secretKey);
 }

EnvelopeGenerator.Application/Common/Interfaces/Services/IEnvelopeTypeService.cs

@@ -0,0 +1,13 @@
+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 IEnvelopeTypeService : IBasicCRUDService<EnvelopeTypeDto, EnvelopeType, int>
+{
+}

EnvelopeGenerator.Application/Common/Interfaces/Services/IReceiverService.cs

@@ -0,0 +1,30 @@
+using DigitalData.Core.Abstraction.Application;
+using DigitalData.Core.Abstraction.Application.DTO;
+using EnvelopeGenerator.Application.Common.Dto.Receiver;
+using EnvelopeGenerator.Application.Receivers.Commands;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+
+/// <summary>
+/// 
+/// </summary>
+[Obsolete("Use MediatR")]
+public interface IReceiverService : ICRUDService<CreateReceiverCommand, ReceiverDto, Receiver, int>
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="emailAddress"></param>
+    /// <param name="signature"></param>
+    /// <returns></returns>
+    Task<DataResult<ReceiverDto>> ReadByAsync(string? emailAddress = null, string? signature = null);
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="emailAddress"></param>
+    /// <param name="signature"></param>
+    /// <returns></returns>
+    Task<Result> DeleteByAsync(string? emailAddress = null, string? signature = null);
+}

EnvelopeGenerator.Application/Common/Interfaces/Services/ISmsSender.cs

@@ -0,0 +1,23 @@
+using EnvelopeGenerator.Application.Common.Dto.Messaging;
+
+namespace EnvelopeGenerator.Application.Common.Interfaces.Services;
+
+//TODO: move to DigitalData.Core
+/// <summary>
+/// 
+/// </summary>
+public interface ISmsSender
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    string ServiceProvider { get; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="recipient"></param>
+    /// <param name="message"></param>
+    /// <returns></returns>
+    Task<SmsResponse> SendSmsAsync(string recipient, string message);
+}

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

@@ -0,0 +1,88 @@
+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; } = null!;
+
+    /// <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;
+        }
+    }
+}

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

@@ -0,0 +1,34 @@
+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 Task Handle(DocSignedNotification notification, CancellationToken cancel)
+        => _repo.CreateAsync(notification.PsPdfKitAnnotation.Structured, cancel);
+}

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

@@ -0,0 +1,39 @@
+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 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 = JsonSerializer.Serialize(notification.PsPdfKitAnnotation.Instant, Format.Json.ForAnnotations)
+        }, cancel);
+    }
+}

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

@@ -0,0 +1,42 @@
+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);
+    }
+}

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

@@ -0,0 +1,50 @@
+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;
+    }
+}

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

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

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

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

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

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

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

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

EnvelopeGenerator.Application/Common/Notifications/SendMailHandler.cs

@@ -0,0 +1,135 @@
+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;
+    }
+}

EnvelopeGenerator.Application/Common/Query/EnvelopeQueryBase.cs

@@ -0,0 +1,17 @@
+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; }
+}

EnvelopeGenerator.Application/Common/Query/EnvelopeReceiverQueryBase.cs

@@ -0,0 +1,62 @@
+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();
+}

EnvelopeGenerator.Application/Common/Query/MappingProfile.cs

@@ -0,0 +1,20 @@
+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>();
+    }
+}

EnvelopeGenerator.Application/Common/Query/ReceiverQueryBase.cs

@@ -0,0 +1,33 @@
+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;
+}

EnvelopeGenerator.Application/Common/SQL/DocumentCreateReadSQL.cs

@@ -0,0 +1,50 @@
+using Dapper;
+using DigitalData.Core.Exceptions;
+using EnvelopeGenerator.Domain.Entities;
+using EnvelopeGenerator.Application.Common.Interfaces.SQLExecutor;
+
+namespace EnvelopeGenerator.Application.Common.SQL;
+
+/// <summary>
+/// 
+/// </summary>
+public class DocumentCreateReadSQL : ISQL<Document>
+{
+    /// <summary>
+    /// Base64, OUT_UID
+    /// </summary>
+    public string Raw => @"
+        DECLARE @BYTE_DATA1 as VARBINARY(MAX)
+        SET @BYTE_DATA1 = @ByteData
+        DECLARE	@OUT_DOCID int
+
+        EXEC	[dbo].[PRSIG_API_ADD_DOC]
+		        {0},
+		        @BYTE_DATA1,
+		        @OUT_DOCID OUTPUT
+
+        SELECT TOP(1) *
+          FROM [dbo].[TBSIG_ENVELOPE_DOCUMENT]
+          WHERE [GUID] = @OUT_DOCID
+    ";
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="base64"></param>
+    /// <returns></returns>
+    public static DynamicParameters CreateParmas(string base64)
+    {
+        try
+        {
+            var parameters = new DynamicParameters();
+            byte[] byteData = Convert.FromBase64String(base64);
+            parameters.Add("ByteData", byteData, System.Data.DbType.Binary);
+            return parameters;
+        }
+        catch(FormatException ex)
+        {
+            throw new BadRequestException(ex.Message.Replace("input", "dataAsBase64"));
+        }
+    }
+}

EnvelopeGenerator.Application/Common/SQL/EnvelopeCreateReadSQL.cs

@@ -0,0 +1,49 @@
+using Dapper;
+using EnvelopeGenerator.Application.Common.Interfaces.SQLExecutor;
+using EnvelopeGenerator.Domain.Entities;
+using System.Data;
+
+namespace EnvelopeGenerator.Application.Common.SQL;
+
+/// <summary>
+/// 
+/// </summary>
+public class EnvelopeCreateReadSQL : ISQL<Envelope>
+{
+    /// <summary>
+    /// USER_ID, TITLE, TFAEnabled, MESSAGE
+    /// </summary>
+    public string Raw => @"
+        DECLARE @OUT_UID varchar(36);
+
+        EXEC [dbo].[PRSIG_API_CREATE_ENVELOPE]
+            {0},
+            {1},
+            {2},
+            {3},
+            @OUT_UID OUTPUT;
+
+        SELECT TOP(1) *
+        FROM [dbo].[TBSIG_ENVELOPE]
+        WHERE [ENVELOPE_UUID] = @OUT_UID;
+    ";
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="userId"></param>
+    /// <param name="title"></param>
+    /// <param name="message"></param>
+    /// <param name="tfaEnabled"></param>
+    /// <returns></returns>
+    public static DynamicParameters CreateParams(int userId, string title = "", string message = "", bool tfaEnabled = false)
+    {
+        var parameters = new DynamicParameters();
+        parameters.Add("@UserId", userId);
+        parameters.Add("@Title", title);
+        parameters.Add("@TfaEnabled", tfaEnabled ? 1 : 0);
+        parameters.Add("@Message", message);
+        parameters.Add("@OutUid", dbType: DbType.String, size: 36, direction: ParameterDirection.Output);
+        return parameters;
+    }
+}

EnvelopeGenerator.Application/Common/SQL/EnvelopeReceiverAddReadSQL.cs

@@ -0,0 +1,47 @@
+using Dapper;
+using EnvelopeGenerator.Application.Common.Interfaces.SQLExecutor;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Common.SQL;
+
+/// <summary>
+/// 
+/// </summary>
+public class EnvelopeReceiverAddReadSQL : ISQL<Envelope>
+{
+    /// <summary>
+    /// ENV_UID, EMAIL_ADRESS, SALUTATION, PHONE, 
+    /// </summary>
+    public string Raw => @"
+		DECLARE	@OUT_RECEIVER_ID int
+
+		EXEC	[dbo].[PRSIG_API_CREATE_RECEIVER]
+				{0},
+				{1},
+				{2},
+				{3},
+				@OUT_RECEIVER_ID OUTPUT
+
+        SELECT TOP(1) [ENVELOPE_ID] As EnvelopeId, [RECEIVER_ID] As ReceiverId
+        FROM [dbo].[TBSIG_ENVELOPE_RECEIVER]
+		WHERE [GUID] = @OUT_RECEIVER_ID;
+	";
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="envelope_uuid"></param>
+    /// <param name="emailAddress"></param>
+    /// <param name="salutation"></param>
+    /// <param name="phone"></param>
+    /// <returns></returns>
+    public static DynamicParameters CreateParameters(string envelope_uuid, string emailAddress, string? salutation = null, string? phone = null)
+    {
+        var parameters = new DynamicParameters();
+        parameters.Add("@ENV_UID", envelope_uuid);
+        parameters.Add("@EMAIL_ADRESS", emailAddress);
+        parameters.Add("@SALUTATION", salutation);
+        parameters.Add("@PHONE", phone);
+        return parameters;
+    }
+}

EnvelopeGenerator.Application/Common/SQL/ParamsExtensions.cs

@@ -0,0 +1,30 @@
+using System.Globalization;
+
+namespace EnvelopeGenerator.Application.Common.SQL;
+
+/// <summary>
+/// Extension method for converting objects to SQL parameter strings.
+/// </summary>
+public static class ParamsExtensions
+{
+    /// <summary>
+    /// Converts a .NET object to its corresponding SQL-safe parameter string.
+    /// </summary>
+    /// <param name="obj">The object to convert.</param>
+    /// <returns>A string representing the SQL parameter.</returns>
+    public static string ToSqlParam(this object? obj)
+    {
+        if (obj is null)
+            return "NULL";
+        else if (obj is string strVal)
+            return $"'{strVal}'";
+        else if (obj is bool boolVal)
+            return boolVal ? "1" : "0";
+        else if (obj is double doubleVal)
+            return $"'{doubleVal.ToString(CultureInfo.InvariantCulture)}'";
+        else if (obj is int intVal)
+            return intVal.ToString();
+        else
+            throw new NotSupportedException($"Type '{obj.GetType().FullName}' is not supported for SQL parameter conversion.");
+    }
+}

EnvelopeGenerator.Application/Configurations/AuthenticatorParams.cs

@@ -1,19 +0,0 @@
-namespace EnvelopeGenerator.Application.Configurations
-{
-    public class AuthenticatorParams
-    {
-        public string CharPool { get; init; } = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567890123456789012345678901234567890123456789";
-
-        //TODO: Increase the DefaultTotpSecretKeyLength (e.g. to 32) but make sure that the QR code is generated correctly and can be scanned by the authenticator.
-        public int DefaultTotpSecretKeyLength { get; init; } = 20;
-
-        public string TotpIssuer { get; init; } = "signFlow";
-
-        /// <summary>
-        /// 0 is user email, 1 is secret key and 2 is issuer.
-        /// </summary>
-        public string TotpUrlFormat { get; init; } = "otpauth://totp/{0}?secret={1}&issuer={2}";
-
-        public int TotpQRPixelsPerModule { get; init; } = 20;
-    }
-}

EnvelopeGenerator.Application/Configurations/DbTriggerParams.cs

@@ -1,5 +0,0 @@
-namespace EnvelopeGenerator.Application.Configurations;
-
-public class DbTriggerParams : Dictionary<string, IEnumerable<string>>
-{
-}

EnvelopeGenerator.Application/Configurations/DispatcherParams.cs

@@ -1,12 +0,0 @@
-namespace EnvelopeGenerator.Application.Configurations;
-
-public class DispatcherParams
-{
-    public int SendingProfile { get; init; } = 1;
-
-    public string AddedWho { get; init; } = "DDEnvelopGenerator";
-
-    public int ReminderTypeId { get; init; } = 202377;
-
-    public string EmailAttmt1 { get; init; } = string.Empty;
-}

EnvelopeGenerator.Application/Configurations/MailParams.cs

@@ -1,6 +0,0 @@
-namespace EnvelopeGenerator.Application.Configurations;
-
-public class MailParams
-{
-    public required Dictionary<string, string> Placeholders { get; init; }
-}

EnvelopeGenerator.Application/Configurations/TotpSmsParams.cs

@@ -1,49 +0,0 @@
-using OtpNet;
-using System.Globalization;
-
-namespace EnvelopeGenerator.Application.Configurations
-{
-    public class TotpSmsParams
-    {
-        /// <summary>
-        /// The unit is second.
-        /// </summary>
-        public int TotpStep { get; init; } = 90;
-
-        public string Format { get; init; } = "Ihr 2FA-Passwort lautet {0}. Gültig bis {1}";
-        
-        public ExpirationHandler Expiration { get; init; } = new();
-
-        public VerificationWindow? TotpVerificationWindow { get; private init; } = VerificationWindow.RfcSpecifiedNetworkDelay;
-
-        private IEnumerable<int>? _tvwParams;
-
-        public IEnumerable<int>? TotpVerificationWindowParams
-        {
-            get => _tvwParams;
-            init
-            {
-                _tvwParams = value;
-                if(_tvwParams is not null)
-                    TotpVerificationWindow = new(previous: _tvwParams.ElementAtOrDefault(0), future: _tvwParams.ElementAtOrDefault(0));
-            }
-        }
-
-        public class ExpirationHandler
-        {
-            public string CacheKeyFormat { get; init; } = "e{0}_r{1}_sms_code_expiration";
-
-            public string Format { get; init; } = "HH:mm:ss";
-
-            public string CultureName
-            {
-                get => _cultureInfo.Name;
-                init => _cultureInfo = new(value);
-            }
-
-            private CultureInfo _cultureInfo = new("de-DE");
-
-            public CultureInfo CultureInfo => _cultureInfo;
-        }
-    }
-}

EnvelopeGenerator.Application/Contracts/Repositories/IConfigRepository.cs

@@ -1,9 +0,0 @@
-using DigitalData.Core.Abstractions.Infrastructure;
-using EnvelopeGenerator.Domain.Entities;
-
-namespace EnvelopeGenerator.Application.Contracts.Repositories;
-
-public interface IConfigRepository : ICRUDRepository<Config, int>
-{
-    Task<Config?> ReadFirstAsync();
-}

EnvelopeGenerator.Application/Contracts/Repositories/IDocumentReceiverElementRepository.cs

@@ -1,8 +0,0 @@
-using DigitalData.Core.Abstractions.Infrastructure;
-using EnvelopeGenerator.Domain.Entities;
-
-namespace EnvelopeGenerator.Application.Contracts.Repositories;
-
-public interface IDocumentReceiverElementRepository : ICRUDRepository<DocumentReceiverElement, int>
-{
-}

EnvelopeGenerator.Application/Contracts/Repositories/IDocumentStatusRepository.cs

@@ -1,8 +0,0 @@
-using DigitalData.Core.Abstractions.Infrastructure;
-using EnvelopeGenerator.Domain.Entities;
-
-namespace EnvelopeGenerator.Application.Contracts.Repositories;
-
-public interface IDocumentStatusRepository : ICRUDRepository<DocumentStatus, int>
-{
-}

EnvelopeGenerator.Application/Contracts/Repositories/IEmailTemplateRepository.cs

@@ -1,10 +0,0 @@
-using DigitalData.Core.Abstractions.Infrastructure;
-using EnvelopeGenerator.Domain.Entities;
-using static EnvelopeGenerator.Common.Constants;
-
-namespace EnvelopeGenerator.Application.Contracts.Repositories;
-
-public interface IEmailTemplateRepository : ICRUDRepository<EmailTemplate, int>
-{
-    Task<EmailTemplate?> ReadByNameAsync(EmailTemplateType type);
-}

EnvelopeGenerator.Application/Contracts/Repositories/IEnvelopeCertificateRepository.cs

@@ -1,8 +0,0 @@
-using DigitalData.Core.Abstractions.Infrastructure;
-using EnvelopeGenerator.Domain.Entities;
-
-namespace EnvelopeGenerator.Application.Contracts.Repositories;
-
-public interface IEnvelopeCertificateRepository : ICRUDRepository<EnvelopeCertificate, int>
-{
-}

EnvelopeGenerator.Application/Contracts/Repositories/IEnvelopeDocumentRepository.cs

@@ -1,8 +0,0 @@
-using DigitalData.Core.Abstractions.Infrastructure;
-using EnvelopeGenerator.Domain.Entities;
-
-namespace EnvelopeGenerator.Application.Contracts.Repositories;
-
-public interface IEnvelopeDocumentRepository : ICRUDRepository<EnvelopeDocument, int>
-{
-}

EnvelopeGenerator.Application/Contracts/Repositories/IEnvelopeHistoryRepository.cs

@@ -1,11 +0,0 @@
-using DigitalData.Core.Abstractions.Infrastructure;
-using EnvelopeGenerator.Domain.Entities;
-
-namespace EnvelopeGenerator.Application.Contracts.Repositories;
-
-public interface IEnvelopeHistoryRepository : ICRUDRepository<EnvelopeHistory, long>
-{
-    Task<int> CountAsync(int? envelopeId = null, string? userReference = null, int? status = null);
-
-    Task<IEnumerable<EnvelopeHistory>> ReadAsync(int? envelopeId = null, string? userReference = null, int? status = null, bool withSender = false, bool withReceiver = false);
-}

EnvelopeGenerator.Application/Contracts/Repositories/IEnvelopeReceiverReadOnlyRepository.cs

@@ -1,8 +0,0 @@
-using DigitalData.Core.Abstractions.Infrastructure;
-using EnvelopeGenerator.Domain.Entities;
-
-namespace EnvelopeGenerator.Application.Contracts.Repositories;
-
-public interface IEnvelopeReceiverReadOnlyRepository : ICRUDRepository<EnvelopeReceiverReadOnly, long>
-{
-}