feat(program): Konfiguration aus appsettings.json laden

Die Anwendung lädt nun Konfigurationseinstellungen aus einer "appsettings.json"-Datei im Basisverzeichnis.
Dies ermöglicht eine externe Konfiguration ohne Codeänderungen und unterstützt das Neuladen der Einstellungen zur Laufzeit bei Änderungen der Datei.

.gitignore

@@ -363,3 +363,5 @@ MigrationBackup/
 FodyWeavers.xsd
 /EnvelopeGenerator.Web/.config/dotnet-tools.json
 /EnvelopeGenerator.GeneratorAPI/ClientApp/envelope-generator-ui/.vscode
+/EnvelopeGenerator.Tests.Application/Services/BugFixTests.cs
+/EnvelopeGenerator.Tests.Application/annotations.json

EnvelopeGenerator.Application/Configurations/AuthenticatorParams.cs

@@ -0,0 +1,19 @@
+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

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

EnvelopeGenerator.Application/Configurations/DispatcherParams.cs

@@ -0,0 +1,12 @@
+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/GtxMessagingParams.cs

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

EnvelopeGenerator.Application/Configurations/MailParams.cs

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

EnvelopeGenerator.Application/Configurations/TotpSmsParams.cs

@@ -0,0 +1,49 @@
+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/IConfigService.cs

@@ -1,17 +0,0 @@
-using DigitalData.Core.Abstractions.Application;
-using DigitalData.Core.DTO;
-using EnvelopeGenerator.Application.DTOs;
-using EnvelopeGenerator.Domain.Entities;
-
-namespace EnvelopeGenerator.Application.Contracts
-{
-    public interface IConfigService : IBasicCRUDService<ConfigDto, Config, int>
-    {
-        Task<DataResult<ConfigDto>> ReadFirstAsync();
-
-        Task<ConfigDto> ReadDefaultAsync();
-
-        Task<string> ReadDefaultSignatureHost();
-
-	}
-}

EnvelopeGenerator.Application/Contracts/IDocumentReceiverElementService.cs

@@ -1,10 +0,0 @@
-using DigitalData.Core.Abstractions.Application;
-using EnvelopeGenerator.Application.DTOs;
-using EnvelopeGenerator.Domain.Entities;
-
-namespace EnvelopeGenerator.Application.Contracts
-{
-    public interface IDocumentReceiverElementService : IBasicCRUDService<DocumentReceiverElementDto, DocumentReceiverElement, int>
-    {
-    }
-}

EnvelopeGenerator.Application/Contracts/IDocumentStatusService.cs

@@ -1,9 +0,0 @@
-using DigitalData.Core.Abstractions.Application;
-using EnvelopeGenerator.Application.DTOs;
-using EnvelopeGenerator.Domain.Entities;
-namespace EnvelopeGenerator.Application.Contracts
-{
-    public interface IDocumentStatusService : IBasicCRUDService<DocumentStatusDto, DocumentStatus, int>
-    {
-    }
-}

EnvelopeGenerator.Application/Contracts/IEmailTemplateService.cs

@@ -1,13 +0,0 @@
-using DigitalData.Core.Abstractions.Application;
-using DigitalData.Core.DTO;
-using EnvelopeGenerator.Application.DTOs;
-using EnvelopeGenerator.Domain.Entities;
-using static EnvelopeGenerator.Common.Constants;
-
-namespace EnvelopeGenerator.Application.Contracts
-{
-    public interface IEmailTemplateService : IBasicCRUDService<EmailTemplateDto, EmailTemplate, int>
-    {
-        Task<DataResult<EmailTemplateDto>> ReadByNameAsync(EmailTemplateType type);
-    }
-}

EnvelopeGenerator.Application/Contracts/IEnvelopeCertificateService.cs

@@ -1,10 +0,0 @@
-using DigitalData.Core.Abstractions.Application;
-using EnvelopeGenerator.Application.DTOs;
-using EnvelopeGenerator.Domain.Entities;
-
-namespace EnvelopeGenerator.Application.Contracts
-{
-    public interface IEnvelopeCertificateService : IBasicCRUDService<EnvelopeCertificateDto, EnvelopeCertificate, int>
-    {
-    }
-}

EnvelopeGenerator.Application/Contracts/IEnvelopeDocumentService.cs

@@ -1,10 +0,0 @@
-using DigitalData.Core.Abstractions.Application;
-using EnvelopeGenerator.Application.DTOs;
-using EnvelopeGenerator.Domain.Entities;
-
-namespace EnvelopeGenerator.Application.Contracts
-{
-    public interface IEnvelopeDocumentService : IBasicCRUDService<EnvelopeDocumentDto, EnvelopeDocument, int>
-    {
-    }
-}

EnvelopeGenerator.Application/Contracts/IEnvelopeHistoryService.cs

@@ -1,29 +0,0 @@
-using DigitalData.Core.Abstractions.Application;
-using DigitalData.Core.DTO;
-using EnvelopeGenerator.Application.DTOs.EnvelopeHistory;
-using EnvelopeGenerator.Application.DTOs.Receiver;
-using EnvelopeGenerator.Domain.Entities;
-using EnvelopeGenerator.Infrastructure.Contracts;
-using static EnvelopeGenerator.Common.Constants;
-
-namespace EnvelopeGenerator.Application.Contracts
-{
-    public interface IEnvelopeHistoryService : ICRUDService<EnvelopeHistoryCreateDto, EnvelopeHistoryDto, EnvelopeHistoryDto, EnvelopeHistory, long>
-    {
-        Task<int> CountAsync(int? envelopeId = null, string? userReference = null, int? status = null);
-
-        Task<bool> AccessCodeAlreadyRequested(int envelopeId, string userReference);
-
-        Task<bool> IsSigned(int envelopeId, string userReference);
-
-        Task<bool> IsRejected(int envelopeId, string? userReference = null);
-
-        Task<IEnumerable<EnvelopeHistoryDto>> ReadAsync(int? envelopeId = null, string? userReference = null, ReferenceType? referenceType = null, int? status = null, bool withSender = false, bool withReceiver = false);
-
-        Task<IEnumerable<EnvelopeHistoryDto>> ReadRejectedAsync(int envelopeId, string? userReference = null);
-
-        Task<IEnumerable<ReceiverReadDto>> ReadRejectingReceivers(int envelopeId);
-
-		Task<DataResult<long>> RecordAsync(int envelopeId, string userReference, EnvelopeStatus status, string? comment = null);
-    }
-}

EnvelopeGenerator.Application/Contracts/IEnvelopeMailService.cs

@@ -1,13 +0,0 @@
-using DigitalData.Core.DTO;
-using DigitalData.EmailProfilerDispatcher.Abstraction.Contracts;
-using EnvelopeGenerator.Application.DTOs;
-using EnvelopeGenerator.Common;
-
-namespace EnvelopeGenerator.Application.Contracts
-{
-    public interface IEnvelopeMailService : IEmailOutService
-    {
-        Task<DataResult<int>> SendAsync(EnvelopeReceiverDto envelopeReceiverDto, Constants.EmailTemplateType tempType);
-        Task<DataResult<int>> SendAccessCodeAsync(EnvelopeReceiverDto envelopeReceiverDto);
-    }
-}

EnvelopeGenerator.Application/Contracts/IEnvelopeReceiverService.cs

@@ -1,29 +0,0 @@
-using DigitalData.Core.Abstractions.Application;
-using DigitalData.Core.DTO;
-using EnvelopeGenerator.Application.DTOs;
-using EnvelopeGenerator.Domain.Entities;
-
-namespace EnvelopeGenerator.Application.Contracts
-{
-    public interface IEnvelopeReceiverService : IBasicCRUDService<EnvelopeReceiverDto, EnvelopeReceiver, object>
-    {
-
-        Task<DataResult<IEnumerable<EnvelopeReceiverDto>>> ReadByUuidAsync(string uuid, bool withEnvelope = true, bool withReceiver = false);
-
-        Task<DataResult<IEnumerable<EnvelopeReceiverDto>>> ReadBySignatureAsync(string signature, bool withEnvelope = false, bool withReceiver = true);
-
-        Task<DataResult<EnvelopeReceiverDto>> ReadByUuidSignatureAsync(string uuid, string signature, bool withEnvelope = true, bool withReceiver = true);
-
-        Task<DataResult<EnvelopeReceiverDto>> ReadByEnvelopeReceiverIdAsync(string envelopeReceiverId, bool withEnvelope = true, bool withReceiver = true);
-
-        Task<DataResult<string>> ReadAccessCodeByIdAsync(int envelopeId, int receiverId);
-        
-		Task<DataResult<bool>> VerifyAccessCodeAsync(string uuid, string signature, string accessCode);
-
-        Task<DataResult<bool>> VerifyAccessCodeAsync(string envelopeReceiverId, string accessCode);
-
-        Task<DataResult<bool>> IsExisting(string envelopeReceiverId);
-
-        Task<DataResult<IEnumerable<EnvelopeReceiverDto>>> ReadByUsernameAsync(string username, int? min_status = null, int? max_status = null, params int[] ignore_statuses);
-    }
-}

EnvelopeGenerator.Application/Contracts/IEnvelopeService.cs

@@ -1,15 +0,0 @@
-using DigitalData.Core.Abstractions.Application;
-using DigitalData.Core.DTO;
-using EnvelopeGenerator.Application.DTOs;
-using EnvelopeGenerator.Domain.Entities;
-using EnvelopeGenerator.Infrastructure.Contracts;
-
-namespace EnvelopeGenerator.Application.Contracts
-{
-    public interface IEnvelopeService : IBasicCRUDService<EnvelopeDto, Envelope, int>
-    {
-        Task<DataResult<IEnumerable<EnvelopeDto>>> ReadAllWithAsync(bool documents = false, bool history = false, bool documentReceiverElement = false);
-
-        Task<DataResult<EnvelopeDto>> ReadByUuidAsync(string uuid, bool withDocuments = false, bool withHistory = false, bool withDocumentReceiverElement = false, bool withUser = false, bool withAll = false);
-    }
-}

EnvelopeGenerator.Application/Contracts/IEnvelopeTypeService.cs

@@ -1,10 +0,0 @@
-using DigitalData.Core.Abstractions.Application;
-using EnvelopeGenerator.Application.DTOs;
-using EnvelopeGenerator.Domain.Entities;
-
-namespace EnvelopeGenerator.Application.Contracts
-{
-    public interface IEnvelopeTypeService : IBasicCRUDService<EnvelopeTypeDto, EnvelopeType, int>
-    {
-    }
-}

EnvelopeGenerator.Application/Contracts/IJWTService.cs

@@ -1,24 +0,0 @@
-using Microsoft.IdentityModel.Tokens;
-using System.IdentityModel.Tokens.Jwt;
-using System.Security.Claims;
-using System.Security.Cryptography;
-
-namespace EnvelopeGenerator.Application.Contracts
-{
-    public interface IJWTService<TClaimValue>
-    {
-        public static SymmetricSecurityKey GenerateSecurityKey(int byteSize = 32)
-        {
-            using var rng = RandomNumberGenerator.Create();
-            var randomBytes = new byte[byteSize];
-            rng.GetBytes(randomBytes);
-            var securityKey = new SymmetricSecurityKey(randomBytes);
-
-            return securityKey;
-        }
-
-        string GenerateToken(TClaimValue claimValue);
-
-        JwtSecurityToken? ReadSecurityToken(string token);
-    }
-}

EnvelopeGenerator.Application/Contracts/IReceiverService.cs

@@ -1,14 +0,0 @@
-using DigitalData.Core.Abstractions.Application;
-using DigitalData.Core.DTO;
-using EnvelopeGenerator.Application.DTOs.Receiver;
-using EnvelopeGenerator.Domain.Entities;
-
-namespace EnvelopeGenerator.Application.Contracts
-{
-    public interface IReceiverService : ICRUDService<ReceiverCreateDto, ReceiverReadDto, ReceiverUpdateDto, Receiver, int>
-    {
-        public Task<DataResult<ReceiverReadDto>> ReadByAsync(string? emailAddress = null, string? signature = null);
-
-        public Task<Result> DeleteByAsync(string? emailAddress = null, string? signature = null);
-    }
-}

EnvelopeGenerator.Application/Contracts/IUserReceiverService.cs

@@ -1,11 +0,0 @@
-using DigitalData.Core.Abstractions.Application;
-using EnvelopeGenerator.Application.DTOs;
-using EnvelopeGenerator.Domain.Entities;
-using EnvelopeGenerator.Infrastructure.Contracts;
-
-namespace EnvelopeGenerator.Application.Contracts
-{
-    public interface IUserReceiverService : IBasicCRUDService<UserReceiverDto, UserReceiver, int>
-    {
-    }
-}

EnvelopeGenerator.Application/Contracts/Repositories/IConfigRepository.cs

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,11 @@
+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

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

EnvelopeGenerator.Application/Contracts/Repositories/IEnvelopeReceiverRepository.cs

@@ -0,0 +1,25 @@
+using DigitalData.Core.Abstractions.Infrastructure;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Contracts.Repositories;
+
+public interface IEnvelopeReceiverRepository : ICRUDRepository<EnvelopeReceiver, (int Envelope, int Receiver)>
+{
+    Task<IEnumerable<EnvelopeReceiver>> ReadByUuidAsync(string uuid, bool withEnvelope = true, bool withReceiver = false, bool readOnly = true);
+
+    Task<IEnumerable<EnvelopeReceiver>> ReadBySignatureAsync(string signature, bool withEnvelope = false, bool withReceiver = true, bool readOnly = true);
+
+    Task<EnvelopeReceiver?> ReadByUuidSignatureAsync(string uuid, string signature, bool withEnvelope = true, bool withReceiver = true, bool readOnly = true);
+
+    Task<string?> ReadAccessCodeAsync(string uuid, string signature, bool readOnly = true);
+
+    Task<int> CountAsync(string uuid, string signature);
+
+    Task<EnvelopeReceiver?> ReadByIdAsync(int envelopeId, int receiverId, bool readOnly = true);
+
+    Task<string?> ReadAccessCodeByIdAsync(int envelopeId, int receiverId, bool readOnly = true);
+
+    Task<IEnumerable<EnvelopeReceiver>> ReadByUsernameAsync(string username, int? min_status = null, int? max_status = null, params int[] ignore_statuses);
+
+    Task<EnvelopeReceiver?> ReadLastByReceiver(string email);
+}

EnvelopeGenerator.Application/Contracts/Repositories/IEnvelopeRepository.cs

@@ -0,0 +1,13 @@
+using DigitalData.Core.Abstractions.Infrastructure;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Contracts.Repositories;
+
+public interface IEnvelopeRepository : ICRUDRepository<Envelope, int>
+{
+    Task<IEnumerable<Envelope>> ReadAllWithAsync(bool documents = false, bool history = false, bool documentReceiverElement = false);
+
+    Task<Envelope?> ReadByUuidAsync(string uuid, bool withDocuments = false, bool withHistory = false, bool withDocumentReceiverElement = false, bool withUser = false, bool withAll = false);
+
+    Task<IEnumerable<Envelope>> ReadByUserAsync(int userId, int? min_status = null, int? max_status = null, params int[] ignore_statuses);
+}

EnvelopeGenerator.Application/Contracts/Repositories/IEnvelopeTypeRepository.cs

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

EnvelopeGenerator.Application/Contracts/Repositories/IReceiverRepository.cs

@@ -0,0 +1,9 @@
+using DigitalData.Core.Abstractions.Infrastructure;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Contracts.Repositories;
+
+public interface IReceiverRepository : ICRUDRepository<Receiver, int>
+{
+    Task<Receiver?> ReadByAsync(string? emailAddress = null, string? signature = null);
+}

EnvelopeGenerator.Application/Contracts/Repositories/IUserReceiverRepository.cs

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

EnvelopeGenerator.Application/Contracts/Services/IAuthenticator.cs

@@ -0,0 +1,18 @@
+using OtpNet;
+
+namespace EnvelopeGenerator.Application.Contracts.Services;
+
+public interface IAuthenticator
+{
+    string GenerateCode(int length);
+
+    string GenerateTotpSecretKey(int? length = null);
+
+    byte[] GenerateTotpQrCode(string userEmail, string secretKey, string? issuer = null, string? totpUrlFormat = null, int? pixelsPerModule = null);
+
+    byte[] GenerateTotpQrCode(string userEmail, int? length = null, string? issuer = null, string? totpUrlFormat = null, int? pixelsPerModule = null);
+
+    string GenerateTotp(string secretKey, int step = 30);
+
+    bool VerifyTotp(string totpCode, string secretKey, int step = 30, VerificationWindow? window = null);
+}

EnvelopeGenerator.Application/Contracts/Services/IConfigService.cs

@@ -0,0 +1,16 @@
+using DigitalData.Core.Abstractions.Application;
+using DigitalData.Core.DTO;
+using EnvelopeGenerator.Application.DTOs;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Contracts.Services;
+
+public interface IConfigService : IReadService<ConfigDto, Config, int>
+{
+    Task<DataResult<ConfigDto>> ReadFirstAsync();
+
+    Task<ConfigDto> ReadDefaultAsync();
+
+    Task<string> ReadDefaultSignatureHost();
+
+}

EnvelopeGenerator.Application/Contracts/Services/IDocumentReceiverElementService.cs

@@ -0,0 +1,9 @@
+using DigitalData.Core.Abstractions.Application;
+using EnvelopeGenerator.Application.DTOs;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Contracts.Services;
+
+public interface IDocumentReceiverElementService : IBasicCRUDService<DocumentReceiverElementDto, DocumentReceiverElement, int>
+{
+}

EnvelopeGenerator.Application/Contracts/Services/IDocumentStatusService.cs

@@ -0,0 +1,8 @@
+using DigitalData.Core.Abstractions.Application;
+using EnvelopeGenerator.Application.DTOs;
+using EnvelopeGenerator.Domain.Entities;
+namespace EnvelopeGenerator.Application.Contracts.Services;
+
+public interface IDocumentStatusService : IBasicCRUDService<DocumentStatusDto, DocumentStatus, int>
+{
+}

EnvelopeGenerator.Application/Contracts/Services/IEmailTemplateService.cs

@@ -0,0 +1,12 @@
+using DigitalData.Core.Abstractions.Application;
+using DigitalData.Core.DTO;
+using EnvelopeGenerator.Application.DTOs;
+using EnvelopeGenerator.Domain.Entities;
+using static EnvelopeGenerator.Common.Constants;
+
+namespace EnvelopeGenerator.Application.Contracts.Services;
+
+public interface IEmailTemplateService : IBasicCRUDService<EmailTemplateDto, EmailTemplate, int>
+{
+    Task<DataResult<EmailTemplateDto>> ReadByNameAsync(EmailTemplateType type);
+}

EnvelopeGenerator.Application/Contracts/Services/IEnvelopeCertificateService.cs

@@ -0,0 +1,9 @@
+using DigitalData.Core.Abstractions.Application;
+using EnvelopeGenerator.Application.DTOs;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Contracts.Services;
+
+public interface IEnvelopeCertificateService : IBasicCRUDService<EnvelopeCertificateDto, EnvelopeCertificate, int>
+{
+}

EnvelopeGenerator.Application/Contracts/Services/IEnvelopeDocumentService.cs

@@ -0,0 +1,9 @@
+using DigitalData.Core.Abstractions.Application;
+using EnvelopeGenerator.Application.DTOs;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Contracts.Services;
+
+public interface IEnvelopeDocumentService : IBasicCRUDService<EnvelopeDocumentDto, EnvelopeDocument, int>
+{
+}

EnvelopeGenerator.Application/Contracts/Services/IEnvelopeHistoryService.cs

@@ -0,0 +1,27 @@
+using DigitalData.Core.Abstractions.Application;
+using DigitalData.Core.DTO;
+using EnvelopeGenerator.Application.DTOs.EnvelopeHistory;
+using EnvelopeGenerator.Application.DTOs.Receiver;
+using EnvelopeGenerator.Domain.Entities;
+using static EnvelopeGenerator.Common.Constants;
+
+namespace EnvelopeGenerator.Application.Contracts.Services;
+
+public interface IEnvelopeHistoryService : ICRUDService<EnvelopeHistoryCreateDto, EnvelopeHistoryDto, EnvelopeHistory, long>
+{
+    Task<int> CountAsync(int? envelopeId = null, string? userReference = null, int? status = null);
+
+    Task<bool> AccessCodeAlreadyRequested(int envelopeId, string userReference);
+
+    Task<bool> IsSigned(int envelopeId, string userReference);
+
+    Task<bool> IsRejected(int envelopeId, string? userReference = null);
+
+    Task<IEnumerable<EnvelopeHistoryDto>> ReadAsync(int? envelopeId = null, string? userReference = null, ReferenceType? referenceType = null, int? status = null, bool withSender = false, bool withReceiver = false);
+
+    Task<IEnumerable<EnvelopeHistoryDto>> ReadRejectedAsync(int envelopeId, string? userReference = null);
+
+    Task<IEnumerable<ReceiverReadDto>> ReadRejectingReceivers(int envelopeId);
+
+    Task<DataResult<long>> RecordAsync(int envelopeId, string userReference, EnvelopeStatus status, string? comment = null);
+}

EnvelopeGenerator.Application/Contracts/Services/IEnvelopeMailService.cs

@@ -0,0 +1,18 @@
+using DigitalData.Core.DTO;
+using DigitalData.EmailProfilerDispatcher.Abstraction.Contracts;
+using EnvelopeGenerator.Application.DTOs.EnvelopeReceiver;
+using EnvelopeGenerator.Application.DTOs.EnvelopeReceiverReadOnly;
+using EnvelopeGenerator.Common;
+
+namespace EnvelopeGenerator.Application.Contracts.Services;
+
+public interface IEnvelopeMailService : IEmailOutService
+{
+    Task<DataResult<int>> SendAsync(EnvelopeReceiverDto envelopeReceiverDto, Constants.EmailTemplateType tempType, Dictionary<string, object>? optionalPlaceholders = null);
+
+    Task<DataResult<int>> SendAsync(EnvelopeReceiverReadOnlyDto dto, Dictionary<string, object>? optionalPlaceholders = null);
+
+    Task<DataResult<int>> SendAccessCodeAsync(EnvelopeReceiverDto envelopeReceiverDto);
+
+    Task<DataResult<int>> SendTFAQrCodeAsync(EnvelopeReceiverDto envelopeReceiverDto);
+}

EnvelopeGenerator.Application/Contracts/Services/IEnvelopeReceiverReadOnlyService.cs

@@ -0,0 +1,9 @@
+using DigitalData.Core.Abstractions.Application;
+using EnvelopeGenerator.Application.DTOs.EnvelopeReceiverReadOnly;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Contracts.Services;
+
+public interface IEnvelopeReceiverReadOnlyService : ICRUDService<EnvelopeReceiverReadOnlyCreateDto, EnvelopeReceiverReadOnlyDto, EnvelopeReceiverReadOnly, long>
+{
+}

EnvelopeGenerator.Application/Contracts/Services/IEnvelopeReceiverService.cs

@@ -0,0 +1,40 @@
+using CommandDotNet;
+using DigitalData.Core.Abstractions.Application;
+using DigitalData.Core.DTO;
+using EnvelopeGenerator.Application.DTOs.EnvelopeReceiver;
+using EnvelopeGenerator.Application.DTOs.Messaging;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Contracts.Services;
+
+public interface IEnvelopeReceiverService : IBasicCRUDService<EnvelopeReceiverDto, EnvelopeReceiver, (int Envelope, int Receiver)>
+{
+
+    Task<DataResult<IEnumerable<EnvelopeReceiverDto>>> ReadByUuidAsync(string uuid, bool withEnvelope = true, bool withReceiver = false, bool readOnly = true);
+
+    Task<DataResult<IEnumerable<string?>>> ReadAccessCodeByUuidAsync(string uuid, bool withEnvelope = false, bool withReceiver = true);
+
+    Task<DataResult<IEnumerable<EnvelopeReceiverDto>>> ReadBySignatureAsync(string signature, bool withEnvelope = false, bool withReceiver = true, bool readOnly = true);
+
+    Task<DataResult<EnvelopeReceiverDto>> ReadByUuidSignatureAsync(string uuid, string signature, bool withEnvelope = true, bool withReceiver = true, bool readOnly = true);
+
+    Task<DataResult<EnvelopeReceiverSecretDto>> ReadWithSecretByUuidSignatureAsync(string uuid, string signature, bool withEnvelope = true, bool withReceiver = true, bool readOnly = true);
+
+    Task<DataResult<EnvelopeReceiverDto>> ReadByEnvelopeReceiverIdAsync(string envelopeReceiverId, bool withEnvelope = true, bool withReceiver = true, bool readOnly = true);
+
+    Task<DataResult<string>> ReadAccessCodeByIdAsync(int envelopeId, int receiverId);
+
+    Task<DataResult<bool>> VerifyAccessCodeAsync(string uuid, string signature, string accessCode);
+
+    [Command("verify-access-code-async-by-id")]
+    Task<DataResult<bool>> VerifyAccessCodeAsync(string envelopeReceiverId, string accessCode);
+
+    Task<DataResult<bool>> IsExisting(string envelopeReceiverId);
+
+    Task<DataResult<IEnumerable<EnvelopeReceiverDto>>> ReadByUsernameAsync(string username, int? min_status = null, int? max_status = null, params int[] ignore_statuses);
+
+    Task<DataResult<string?>> ReadLastUsedReceiverNameByMail(string mail);
+
+    Task<DataResult<SmsResponse>> SendSmsAsync(string envelopeReceiverId, string message);
+    Task<DataResult<IEnumerable<EnvelopeReceiverSecretDto>>> ReadWithSecretByUuidAsync(string uuid);
+}

EnvelopeGenerator.Application/Contracts/Services/IEnvelopeService.cs

@@ -0,0 +1,15 @@
+using DigitalData.Core.Abstractions.Application;
+using DigitalData.Core.DTO;
+using EnvelopeGenerator.Application.DTOs;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Contracts.Services;
+
+public interface IEnvelopeService : IBasicCRUDService<EnvelopeDto, Envelope, int>
+{
+    Task<DataResult<IEnumerable<EnvelopeDto>>> ReadAllWithAsync(bool documents = false, bool history = false, bool documentReceiverElement = false);
+
+    Task<DataResult<EnvelopeDto>> ReadByUuidAsync(string uuid, bool withDocuments = false, bool withHistory = false, bool withDocumentReceiverElement = false, bool withUser = false, bool withAll = false);
+
+    Task<DataResult<IEnumerable<EnvelopeDto>>> ReadByUserAsync(int userId, int? min_status = null, int? max_status = null, params int[] ignore_statuses);
+}

EnvelopeGenerator.Application/Contracts/Services/IEnvelopeSmsHandler.cs

@@ -0,0 +1,17 @@
+using EnvelopeGenerator.Application.DTOs.EnvelopeReceiver;
+using EnvelopeGenerator.Application.DTOs.Messaging;
+
+namespace EnvelopeGenerator.Application.Contracts.Services;
+
+public interface IEnvelopeSmsHandler
+{
+    /// <summary>
+    /// If expiration is passed then, sends sms and returns smsResponse and up-to-date expiration; otherwise send expiration.
+    /// </summary>
+    /// <param name="er_secret"></param>
+    /// <param name="cToken"></param>
+    /// <returns></returns>
+    Task<(SmsResponse? SmsResponse, DateTime Expiration)> SendTotpAsync(EnvelopeReceiverSecretDto er_secret, CancellationToken cToken = default);
+
+    bool VerifyTotp(string totpCode, string secretKey);
+}

EnvelopeGenerator.Application/Contracts/Services/IEnvelopeTypeService.cs

@@ -0,0 +1,9 @@
+using DigitalData.Core.Abstractions.Application;
+using EnvelopeGenerator.Application.DTOs;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Contracts.Services;
+
+public interface IEnvelopeTypeService : IBasicCRUDService<EnvelopeTypeDto, EnvelopeType, int>
+{
+}

EnvelopeGenerator.Application/Contracts/Services/IReceiverService.cs

@@ -0,0 +1,16 @@
+using DigitalData.Core.Abstractions;
+using DigitalData.Core.Abstractions.Application;
+using DigitalData.Core.DTO;
+using EnvelopeGenerator.Application.DTOs.Receiver;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Contracts.Services;
+
+public interface IReceiverService : ICRUDService<ReceiverCreateDto, ReceiverReadDto, Receiver, int>
+{
+    Task<DataResult<ReceiverReadDto>> ReadByAsync(string? emailAddress = null, string? signature = null);
+
+    Task<Result> DeleteByAsync(string? emailAddress = null, string? signature = null);
+
+    Task<Result> UpdateAsync<TUpdateDto>(TUpdateDto updateDto) where TUpdateDto : IUnique<int>;
+}

EnvelopeGenerator.Application/Contracts/Services/ISmsSender.cs

@@ -0,0 +1,11 @@
+using EnvelopeGenerator.Application.DTOs.Messaging;
+
+namespace EnvelopeGenerator.Application.Contracts.Services;
+
+//TODO: move to DigitalData.Core
+public interface ISmsSender
+{
+    string ServiceProvider { get; }
+
+    Task<SmsResponse> SendSmsAsync(string recipient, string message);
+}

EnvelopeGenerator.Application/Contracts/Services/IUserReceiverService.cs

@@ -0,0 +1,9 @@
+using DigitalData.Core.Abstractions.Application;
+using EnvelopeGenerator.Application.DTOs;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Contracts.Services;
+
+public interface IUserReceiverService : IBasicCRUDService<UserReceiverDto, UserReceiver, int>
+{
+}

EnvelopeGenerator.Application/DIExtensions.cs

@@ -1,57 +0,0 @@
-using DigitalData.UserManager.Application.MappingProfiles;
-using EnvelopeGenerator.Application.Contracts;
-using EnvelopeGenerator.Application.MappingProfiles;
-using EnvelopeGenerator.Application.Services;
-using EnvelopeGenerator.Infrastructure.Contracts;
-using EnvelopeGenerator.Infrastructure.Repositories;
-using Microsoft.Extensions.DependencyInjection;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace EnvelopeGenerator.Application
-{
-    public static class DIExtensions
-    {
-        public static IServiceCollection AddEnvelopeGenerator(this IServiceCollection services)
-        {
-            //Inject CRUD Service and repositoriesad
-            services.AddScoped<IConfigRepository, ConfigRepository>();
-            services.AddScoped<IDocumentReceiverElementRepository, DocumentReceiverElementRepository>();
-            services.AddScoped<IEnvelopeDocumentRepository, EnvelopeDocumentRepository>();
-            services.AddScoped<IConfigRepository, ConfigRepository>();
-            services.AddScoped<IDocumentReceiverElementRepository, DocumentReceiverElementRepository>();
-            services.AddScoped<IDocumentStatusRepository, DocumentStatusRepository>();
-            services.AddScoped<IEmailTemplateRepository, EmailTemplateRepository>();
-            services.AddScoped<IEnvelopeRepository, EnvelopeRepository>();
-            services.AddScoped<IEnvelopeCertificateRepository, EnvelopeCertificateRepository>();
-            services.AddScoped<IEnvelopeDocumentRepository, EnvelopeDocumentRepository>();
-            services.AddScoped<IEnvelopeHistoryRepository, EnvelopeHistoryRepository>();
-            services.AddScoped<IEnvelopeReceiverRepository, EnvelopeReceiverRepository>();
-            services.AddScoped<IEnvelopeTypeRepository, EnvelopeTypeRepository>();
-            services.AddScoped<IReceiverRepository, ReceiverRepository>();
-            services.AddScoped<IUserReceiverRepository, UserReceiverRepository>();
-            services.AddScoped<IConfigService, ConfigService>();
-            services.AddScoped<IDocumentReceiverElementService, DocumentReceiverElementService>();
-            services.AddScoped<IEnvelopeDocumentService, EnvelopeDocumentService>();
-            services.AddScoped<IEnvelopeHistoryService, EnvelopeHistoryService>();
-            services.AddScoped<IDocumentStatusService, DocumentStatusService>();
-            services.AddScoped<IEmailTemplateService, EmailTemplateService>();
-            services.AddScoped<IEnvelopeService, EnvelopeService>();
-            services.AddScoped<IEnvelopeCertificateService, EnvelopeCertificateService>();
-            services.AddScoped<IEnvelopeDocumentService, EnvelopeDocumentService>();
-            services.AddScoped<IEnvelopeReceiverService, EnvelopeReceiverService>();
-            services.AddScoped<IEnvelopeTypeService, EnvelopeTypeService>();
-            services.AddScoped<IReceiverService, ReceiverService>();
-            services.AddScoped<IUserReceiverService, UserReceiverService>();
-
-            //Auto mapping profiles
-            services.AddAutoMapper(typeof(BasicDtoMappingProfile).Assembly);
-            services.AddAutoMapper(typeof(UserMappingProfile).Assembly);
-
-            return services;
-        }
-    }
-}

EnvelopeGenerator.Application/DTOs/ConfigDto.cs

@@ -1,12 +1,21 @@
-namespace EnvelopeGenerator.Application.DTOs
+using DigitalData.Core.Abstractions;
+using Microsoft.AspNetCore.Mvc;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Text.Json.Serialization;
+
+namespace EnvelopeGenerator.Application.DTOs
 {
+    [ApiExplorerSettings(IgnoreApi = true)]
     public record ConfigDto(
         string DocumentPath,
         int SendingProfile,
         string SignatureHost,
         string ExternalProgramName,
-        string ExportPath,
-        string DocumentPathDmz,
-        string ExportPathDmz,
-        string DocumentPathMoveAftsend);
+        string ExportPath) : IUnique<int>
+    {
+        [NotMapped]
+        [JsonIgnore]
+        [Obsolete("Configuration does not have an ID; it represents a single table in the database.")]
+        public int Id => throw new InvalidOperationException("This configuration does not support an ID as it represents a single row in the database.");
+    };
 }

EnvelopeGenerator.Application/DTOs/DocumentReceiverElementDto.cs

@@ -1,5 +1,9 @@
-namespace EnvelopeGenerator.Application.DTOs
+using DigitalData.Core.Abstractions;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.DTOs
 {
+    [ApiExplorerSettings(IgnoreApi = true)]
     public record DocumentReceiverElementDto(
         int Id,
         int DocumentId,
@@ -18,5 +22,5 @@
         DateTime? ChangedWhen,
         double Top,
         double Left
-        );
+        ): IUnique<int>;
 }

EnvelopeGenerator.Application/DTOs/DocumentStatusDto.cs

@@ -1,12 +1,18 @@
-namespace EnvelopeGenerator.Application.DTOs
+using DigitalData.Core.Abstractions;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.DTOs
 {
+    [ApiExplorerSettings(IgnoreApi = true)]
     public record DocumentStatusDto(
         int Id,
         int EnvelopeId,
         int ReceiverId,
         int Status,
         DateTime? StatusChangedWhen,
-        string Value,
         DateTime AddedWhen,
-        DateTime? ChangedWhen);
+        DateTime? ChangedWhen) : IUnique<int>
+    {
+        public string? Value { get; set; }
+    };
 }

EnvelopeGenerator.Application/DTOs/EmailTemplateDto.cs

@@ -1,8 +1,12 @@
-namespace EnvelopeGenerator.Application.DTOs
+using DigitalData.Core.Abstractions;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.DTOs
 {
+    [ApiExplorerSettings(IgnoreApi = true)]
     public record EmailTemplateDto(
         int Id,
         string Name,
         string Body,
-        string Subject);
+        string Subject) : IUnique<int>;
 }

EnvelopeGenerator.Application/DTOs/EnvelopeCertificateDto.cs

@@ -1,5 +1,9 @@
-namespace EnvelopeGenerator.Application.DTOs
+using DigitalData.Core.Abstractions;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.DTOs
 {
+    [ApiExplorerSettings(IgnoreApi = true)]
     public record EnvelopeCertificateDto(
         int Id,
         int EnvelopeId,
@@ -8,5 +12,5 @@
         int CreatorId,
         string CreatorName,
         string CreatorEmail,
-        int EnvelopeStatus);
+        int EnvelopeStatus) : IUnique<int>;
 }

EnvelopeGenerator.Application/DTOs/EnvelopeDocumentDto.cs

@@ -1,10 +1,15 @@
-namespace EnvelopeGenerator.Application.DTOs
+using DigitalData.Core.Abstractions;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.DTOs
 {
+    [ApiExplorerSettings(IgnoreApi = true)]
     public record EnvelopeDocumentDto
     (
         int Id,
         int EnvelopeId,
         DateTime AddedWhen,
-        IEnumerable<DocumentReceiverElementDto>? Elements
-    );
+        byte[]? ByteData = null,
+        IEnumerable<DocumentReceiverElementDto>? Elements = null
+    ) : IUnique<int>;
 }

EnvelopeGenerator.Application/DTOs/EnvelopeDto.cs

@@ -1,10 +1,13 @@
-using DigitalData.EmailProfilerDispatcher.Abstraction.Attributes;
+using DigitalData.Core.Abstractions;
+using DigitalData.EmailProfilerDispatcher.Abstraction.Attributes;
 using DigitalData.UserManager.Application.DTOs.User;
 using EnvelopeGenerator.Domain.Entities;
+using Microsoft.AspNetCore.Mvc;
 
 namespace EnvelopeGenerator.Application.DTOs
 {
-    public record EnvelopeDto()
+    [ApiExplorerSettings(IgnoreApi = true)]
+    public record EnvelopeDto() : IUnique<int>
     {
 		public int Id { get; set; }
 
@@ -50,7 +53,9 @@ namespace EnvelopeGenerator.Application.DTOs
 
 		public int? ExpiresWarningWhenDays { get; set; }
 
-		public bool DmzMoved { get; set; }
+        public bool TFAEnabled { get; init; }
+
+        public bool DmzMoved { get; set; }
 		public UserReadDto? User { get; set; }
 		public EnvelopeType? EnvelopeType { get; set; }
 

EnvelopeGenerator.Application/DTOs/EnvelopeHistory/EnvelopeHistoryCreateDto.cs

@@ -1,5 +1,8 @@
-namespace EnvelopeGenerator.Application.DTOs.EnvelopeHistory
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.DTOs.EnvelopeHistory
 {
+    [ApiExplorerSettings(IgnoreApi = true)]
     public record EnvelopeHistoryCreateDto(
         int EnvelopeId,
         string UserReference,

EnvelopeGenerator.Application/DTOs/EnvelopeHistory/EnvelopeHistoryDto.cs

@@ -1,19 +1,23 @@
-using DigitalData.Core.DTO;
+using DigitalData.Core.Abstractions;
+using DigitalData.Core.DTO;
 using DigitalData.UserManager.Application.DTOs.User;
 using EnvelopeGenerator.Application.DTOs.Receiver;
+using Microsoft.AspNetCore.Mvc;
 using static EnvelopeGenerator.Common.Constants;
 
 namespace EnvelopeGenerator.Application.DTOs.EnvelopeHistory
 {
+    [ApiExplorerSettings(IgnoreApi = true)]
     public record EnvelopeHistoryDto(
         long Id,
         int EnvelopeId,
         string UserReference,
         int Status,
+        string? StatusName,
         DateTime AddedWhen,
         DateTime? ActionDate,
         UserCreateDto? Sender,
         ReceiverReadDto? Receiver,
         ReferenceType ReferenceType,
-        string? Comment = null) : BaseDTO<long>(Id);
+        string? Comment = null) : BaseDTO<long>(Id), IUnique<long>;
 }

EnvelopeGenerator.Application/DTOs/EnvelopeReceiver/EnvelopeReceiverBasicDto.cs

@@ -0,0 +1,33 @@
+using DigitalData.Core.Abstractions;
+using DigitalData.EmailProfilerDispatcher.Abstraction.Attributes;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.DTOs.EnvelopeReceiver
+{
+    [ApiExplorerSettings(IgnoreApi = true)]
+    public record EnvelopeReceiverBasicDto() : IUnique<(int Envelope, int Receiver)>
+    {
+        public (int Envelope, int Receiver) Id => (Envelope: EnvelopeId, Receiver: ReceiverId);
+
+        public int EnvelopeId { get; init; }
+
+        public int ReceiverId { get; init; }
+
+        public int Sequence { get; init; }
+
+        [TemplatePlaceholder("[NAME_RECEIVER]")]
+        public string? Name { get; init; }
+
+        public string? JobTitle { get; init; }
+
+        public string? CompanyName { get; init; }
+
+        public string? PrivateMessage { get; init; }
+
+        public DateTime AddedWhen { get; init; }
+
+        public DateTime? ChangedWhen { get; init; }
+
+        public bool HasPhoneNumber { get; init; }
+    }
+}

EnvelopeGenerator.Application/DTOs/EnvelopeReceiver/EnvelopeReceiverDto.cs

@@ -0,0 +1,13 @@
+using EnvelopeGenerator.Application.DTOs.Receiver;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.DTOs.EnvelopeReceiver
+{
+    [ApiExplorerSettings(IgnoreApi = true)]
+    public record EnvelopeReceiverDto() : EnvelopeReceiverBasicDto()
+    {
+        public EnvelopeDto? Envelope { get; set; }
+
+        public ReceiverReadDto? Receiver { get; set; }
+    }
+}

EnvelopeGenerator.Application/DTOs/EnvelopeReceiver/EnvelopeReceiverSecretDto.cs

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

EnvelopeGenerator.Application/DTOs/EnvelopeReceiverDto.cs

@@ -1,31 +0,0 @@
-using DigitalData.EmailProfilerDispatcher.Abstraction.Attributes;
-using EnvelopeGenerator.Application.DTOs.Receiver;
-
-namespace EnvelopeGenerator.Application.DTOs
-{
-    public record EnvelopeReceiverDto()
-    {
-		public int EnvelopeId { get; set; }
-
-		public int ReceiverId { get; set; }
-
-		public int Sequence { get; set; }
-
-		[TemplatePlaceholder("[NAME_RECEIVER]")]
-		public string? Name { get; set; }
-
-		public string? JobTitle { get; set; }
-
-		public string? CompanyName { get; set; }
-
-		public string? PrivateMessage { get; set; }
-		
-		public DateTime AddedWhen { get; set; }
-		
-		public DateTime? ChangedWhen { get; set; }
-				
-		public EnvelopeDto? Envelope { get; set; }
-
-		public ReceiverReadDto? Receiver { get; set; }
-	}
-}

EnvelopeGenerator.Application/DTOs/EnvelopeReceiverReadOnly/EnvelopeReceiverReadOnlyCreateDto.cs

@@ -0,0 +1,24 @@
+using Microsoft.AspNetCore.Mvc;
+using System.ComponentModel.DataAnnotations;
+using System.Text.Json.Serialization;
+
+namespace EnvelopeGenerator.Application.DTOs.EnvelopeReceiverReadOnly
+{
+    [ApiExplorerSettings(IgnoreApi = true)]
+    public record EnvelopeReceiverReadOnlyCreateDto(
+        DateTime DateValid)
+    {
+        [EmailAddress]
+        [Required]
+        public required string ReceiverMail { get; init; }
+
+        [JsonIgnore]
+        public long? EnvelopeId { get; set; } = null;
+
+        [JsonIgnore]
+        public string? AddedWho { get; set; }
+
+        [JsonIgnore]
+        public DateTime AddedWhen { get; } = DateTime.Now;
+    };
+}

EnvelopeGenerator.Application/DTOs/EnvelopeReceiverReadOnly/EnvelopeReceiverReadOnlyDto.cs

@@ -0,0 +1,18 @@
+using EnvelopeGenerator.Application.DTOs.Receiver;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.DTOs.EnvelopeReceiverReadOnly
+{
+    [ApiExplorerSettings(IgnoreApi = true)]
+    public record EnvelopeReceiverReadOnlyDto(
+        long Id,
+        long EnvelopeId,
+        string ReceiverMail,
+        DateTime DateValid,
+        DateTime AddedWhen,
+        string AddedWho,
+        EnvelopeDto? Envelope = null,              
+        string? ChangedWho = null,
+        DateTime? ChangedWhen = null,
+        ReceiverReadDto? Receiver = null);
+}

EnvelopeGenerator.Application/DTOs/EnvelopeReceiverReadOnly/EnvelopeReceiverReadOnlyUpdateDto.cs

@@ -0,0 +1,14 @@
+using DigitalData.Core.Abstractions;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.DTOs.EnvelopeReceiverReadOnly
+{
+    [ApiExplorerSettings(IgnoreApi = true)]
+    public record EnvelopeReceiverReadOnlyUpdateDto(
+        long Id,
+        DateTime DateValid,
+        string ChangedWho) : IUnique<long>
+    {
+        public DateTime ChangedWhen { get; } = DateTime.Now;
+    };
+}

EnvelopeGenerator.Application/DTOs/EnvelopeTypeDto.cs

@@ -1,5 +1,9 @@
-namespace EnvelopeGenerator.Application.DTOs
+using DigitalData.Core.Abstractions;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.DTOs
 {
+    [ApiExplorerSettings(IgnoreApi = true)]
     public record EnvelopeTypeDto(
         int Id,
         string Title,
@@ -15,5 +19,5 @@
         bool? SendReminderEmails,
         int? FirstReminderDays,
         int? ReminderIntervalDays,
-        int? ContractType);
+        int? ContractType) : IUnique<int>;
 }

EnvelopeGenerator.Application/DTOs/MappingProfile.cs

@@ -0,0 +1,70 @@
+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.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.DTOs;
+
+/// <summary>
+/// Represents the AutoMapper profile configuration for mapping between
+/// domain entities and data transfer objects (DTOs) used within the EnvelopeGenerator application.
+/// </summary>
+public class MappingProfile : Profile
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MappingProfile"/> class.
+    /// Configures the mappings between entities and DTOs used throughout the application.
+    /// </summary>
+    public MappingProfile()
+    {
+        // Entity to DTO mappings
+        CreateMap<Config, ConfigDto>();
+        CreateMap<DocumentReceiverElement, DocumentReceiverElementDto>();
+        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<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.EnvelopeReceiverReadOnly, EnvelopeReceiverReadOnlyDto>();
+
+        // DTO to Entity mappings
+        CreateMap<ConfigDto, Config>();
+        CreateMap<DocumentReceiverElementDto, DocumentReceiverElement>();
+        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<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<EnvelopeReceiverReadOnlyCreateDto, Domain.Entities.EnvelopeReceiverReadOnly>();
+        CreateMap<EnvelopeReceiverReadOnlyUpdateDto, Domain.Entities.EnvelopeReceiverReadOnly>();
+
+        // Messaging mappings
+        // for GTX messaging
+        CreateMap<GtxMessagingResponse, SmsResponse>()
+            .ConstructUsing(gtxRes => gtxRes.Ok()
+                ? new SmsResponse() { Ok = true }
+                : new SmsResponse() { Ok = false, Errors = gtxRes });
+    }
+}

EnvelopeGenerator.Application/DTOs/Messaging/GtxMessagingResponse.cs

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

EnvelopeGenerator.Application/DTOs/Messaging/SmsResponse.cs

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

EnvelopeGenerator.Application/DTOs/Receiver/ReceiverCreateDto.cs

@@ -1,10 +1,12 @@
-using System.ComponentModel.DataAnnotations;
+using Microsoft.AspNetCore.Mvc;
+using System.ComponentModel.DataAnnotations;
 using System.Security.Cryptography;
 using System.Text;
 
 namespace EnvelopeGenerator.Application.DTOs.Receiver
 {
-    public record ReceiverCreateDto([EmailAddress] string EmailAddress)
+    [ApiExplorerSettings(IgnoreApi = true)]
+    public record ReceiverCreateDto([EmailAddress] string EmailAddress, string? TotpSecretkey = null)
     {
         public string Signature => sha256HexOfMail.Value;
 

EnvelopeGenerator.Application/DTOs/Receiver/ReceiverReadDto.cs

@@ -1,11 +1,26 @@
-using DigitalData.Core.DTO;
+using DigitalData.Core.Abstractions;
+using DigitalData.Core.DTO;
+using DigitalData.EmailProfilerDispatcher.Abstraction.Attributes;
+using EnvelopeGenerator.Application.DTOs.EnvelopeReceiver;
+using Microsoft.AspNetCore.Mvc;
+using System.Text.Json.Serialization;
 
-namespace EnvelopeGenerator.Application.DTOs.Receiver
+namespace EnvelopeGenerator.Application.DTOs.Receiver;
+
+[ApiExplorerSettings(IgnoreApi = true)]
+public record ReceiverReadDto(
+    int Id,
+    string EmailAddress,
+    string Signature,
+    DateTime AddedWhen
+    ) : BaseDTO<int>(Id), IUnique<int>
 {
-    public record ReceiverReadDto(
-        int Id,
-        string EmailAddress,
-        string Signature,
-        DateTime AddedWhen
-        ) : BaseDTO<int>(Id);
-}
+    [JsonIgnore]
+    public IEnumerable<EnvelopeReceiverBasicDto>? EnvelopeReceivers { get; init; }
+
+    public string? LastUsedName => EnvelopeReceivers?.LastOrDefault()?.Name;
+
+    public string? TotpSecretkey { get; set; } = null;
+
+    public DateTime? TfaRegDeadline { get; set; }
+};

EnvelopeGenerator.Application/DTOs/Receiver/ReceiverUpdateDto.cs

@@ -1,4 +1,7 @@
-namespace EnvelopeGenerator.Application.DTOs.Receiver
-{
-    public record ReceiverUpdateDto();
-}
+using DigitalData.Core.Abstractions;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.DTOs.Receiver;
+
+[ApiExplorerSettings(IgnoreApi = true)]
+public record ReceiverUpdateDto(int Id, string? TotpSecretkey = null, DateTime? TfaRegDeadline = null) : IUnique<int>;

EnvelopeGenerator.Application/DTOs/UserReceiverDto.cs

@@ -1,5 +1,9 @@
-namespace EnvelopeGenerator.Application.DTOs
+using DigitalData.Core.Abstractions;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.DTOs
 {
+    [ApiExplorerSettings(IgnoreApi = true)]
     public record UserReceiverDto(
         int Id,
         int UserId,
@@ -7,5 +11,5 @@
         string Name,
         string CompanyName,
         string JobTitle,
-        DateTime AddedWhen);
+        DateTime AddedWhen) : IUnique<int>;
 }

EnvelopeGenerator.Application/DependencyInjection.cs

@@ -0,0 +1,65 @@
+using EnvelopeGenerator.Application.Configurations;
+using EnvelopeGenerator.Application.Services;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using DigitalData.Core.Client;
+using QRCoder;
+using EnvelopeGenerator.Application.Contracts.Services;
+using System.Reflection;
+
+namespace EnvelopeGenerator.Application;
+
+/// <summary>
+/// Extensions method for dependency injection
+/// </summary>
+public static class DependencyInjection
+{
+    /// <summary>
+    /// Adds all required services for envelope generator application
+    /// </summary>
+    /// <param name="services"></param>
+    /// <param name="config"></param>
+    /// <returns></returns>
+    public static IServiceCollection AddEnvelopeGeneratorServices(this IServiceCollection services, IConfiguration config)
+    {
+        //Inject CRUD Service and repositoriesad
+        services.TryAddScoped<IConfigService, ConfigService>();
+        services.TryAddScoped<IDocumentReceiverElementService, DocumentReceiverElementService>();
+        services.TryAddScoped<IEnvelopeDocumentService, EnvelopeDocumentService>();
+        services.TryAddScoped<IEnvelopeHistoryService, EnvelopeHistoryService>();
+        services.TryAddScoped<IDocumentStatusService, DocumentStatusService>();
+        services.TryAddScoped<IEmailTemplateService, EmailTemplateService>();
+        services.TryAddScoped<IEnvelopeService, EnvelopeService>();
+        services.TryAddScoped<IEnvelopeCertificateService, EnvelopeCertificateService>();
+        services.TryAddScoped<IEnvelopeDocumentService, EnvelopeDocumentService>();
+        services.TryAddScoped<IEnvelopeReceiverService, EnvelopeReceiverService>();
+        services.TryAddScoped<IEnvelopeTypeService, EnvelopeTypeService>();
+        services.TryAddScoped<IReceiverService, ReceiverService>();
+        services.TryAddScoped<IUserReceiverService, UserReceiverService>();
+        services.TryAddScoped<IEnvelopeReceiverReadOnlyService, EnvelopeReceiverReadOnlyService>();
+
+        //Auto mapping profiles
+        services.AddAutoMapper(Assembly.GetExecutingAssembly());
+        services.AddAutoMapper(typeof(DigitalData.UserManager.Application.DIExtensions));
+
+        services.Configure<DispatcherParams>(config.GetSection(nameof(DispatcherParams)));
+        services.Configure<MailParams>(config.GetSection(nameof(MailParams)));
+        services.Configure<AuthenticatorParams>(config.GetSection(nameof(AuthenticatorParams)));
+        services.Configure<TotpSmsParams>(config.GetSection(nameof(TotpSmsParams)));
+        services.Configure<DbTriggerParams>(config.GetSection(nameof(DbTriggerParams)));
+
+        services.AddHttpClientService<GtxMessagingParams>(config.GetSection(nameof(GtxMessagingParams)));
+        services.TryAddSingleton<ISmsSender, GTXSmsSender>();
+        services.TryAddSingleton<IEnvelopeSmsHandler, EnvelopeSmsHandler>();
+        services.TryAddSingleton<IAuthenticator, Authenticator>();
+        services.TryAddSingleton<QRCodeGenerator>();
+
+        services.AddMediatR(cfg =>
+        {
+            cfg.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly());
+        });
+
+        return services;
+    }
+}

EnvelopeGenerator.Application/DispatcherConfig.cs

@@ -1,13 +0,0 @@
-namespace EnvelopeGenerator.Application
-{
-	public class DispatcherConfig
-	{
-		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/Documents/Queries/Read/ReadDocumentMappingProfile.cs

@@ -0,0 +1,18 @@
+using AutoMapper;
+using EnvelopeGenerator.Domain.Entities;
+
+namespace EnvelopeGenerator.Application.Documents.Queries.Read;
+
+/// <summary>
+/// 
+/// </summary>
+public class ReadDocumentMappingProfile : Profile
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public ReadDocumentMappingProfile()
+    {
+        CreateMap<EnvelopeDocument, ReadDocumentResponse>();
+    }
+}

EnvelopeGenerator.Application/Documents/Queries/Read/ReadDocumentQuery.cs

@@ -0,0 +1,12 @@
+using MediatR;
+
+namespace EnvelopeGenerator.Application.Documents.Queries.Read;
+
+/// <summary>
+/// Represents a query to read a document based on its unique identifier or associated envelope identifier.
+/// </summary>
+/// <param name="Id">The unique identifier of the document. Optional.</param>
+/// <param name="EnvelopeId">The identifier of the envelope associated with the document. Optional.</param>
+public record ReadDocumentQuery(int? Id = null, int? EnvelopeId = null) : IRequest<ReadDocumentResponse?>
+{
+}

EnvelopeGenerator.Application/Documents/Queries/Read/ReadDocumentQueryHandler.cs

@@ -0,0 +1,47 @@
+using DigitalData.Core.Abstractions.Infrastructure;
+using EnvelopeGenerator.Domain.Entities;
+using MediatR;
+
+namespace EnvelopeGenerator.Application.Documents.Queries.Read;
+
+/// <summary>
+/// Handles queries for reading <see cref="EnvelopeDocument"/> data based on either the document ID or the envelope ID.
+/// </summary>
+public class ReadDocumentQueryHandler : IRequestHandler<ReadDocumentQuery, ReadDocumentResponse?>
+{
+    /// <summary>
+    /// Repository for accessing <see cref="EnvelopeDocument"/> entities.
+    /// </summary>
+    private readonly IRepository<EnvelopeDocument> _repo;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ReadDocumentQueryHandler"/> class.
+    /// </summary>
+    /// <param name="envelopeDocumentRepository">The repository used to access <see cref="EnvelopeDocument"/> entities.</param>
+    public ReadDocumentQueryHandler(IRepository<EnvelopeDocument> envelopeDocumentRepository)
+    {
+        _repo = envelopeDocumentRepository;
+    }
+
+    /// <summary>
+    /// Handles the <see cref="ReadDocumentQuery"/> and returns a <see cref="ReadDocumentResponse"/> based on the provided identifiers.
+    /// </summary>
+    /// <param name="query">The query containing the document ID or envelope ID to search for.</param>
+    /// <param name="cancellationToken">A token to monitor for cancellation requests.</param>
+    /// <returns>
+    /// A <see cref="ReadDocumentResponse"/> if a matching document is found; otherwise, <c>null</c>.
+    /// </returns>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown when neither <see cref="ReadDocumentQuery.Id"/> nor <see cref="ReadDocumentQuery.EnvelopeId"/> is provided.
+    /// </exception>
+    public async Task<ReadDocumentResponse?> Handle(ReadDocumentQuery query, CancellationToken cancellationToken)
+    {
+        if (query.Id is not null)
+            return await _repo.ReadOrDefaultAsync<ReadDocumentResponse>(d => d.Id == query.Id);
+        else if (query.EnvelopeId is not null)
+            return await _repo.ReadOrDefaultAsync<ReadDocumentResponse>(d => d.EnvelopeId == query.EnvelopeId);
+
+        throw new InvalidOperationException(
+            $"Invalid {nameof(ReadDocumentQuery)}: either {nameof(query.Id)} or {nameof(query.EnvelopeId)} must be provided.");
+    }
+}

EnvelopeGenerator.Application/Documents/Queries/Read/ReadDocumentResponse.cs

@@ -0,0 +1,12 @@
+namespace EnvelopeGenerator.Application.Documents.Queries.Read;
+
+/// <summary>
+/// Represents the response for reading a document.
+/// </summary>
+public class ReadDocumentResponse : ReadDocumentResponseBase
+{
+    /// <summary>
+    /// The binary data of the document, if available.
+    /// </summary>
+    public byte[]? ByteData { get; init; }
+}

EnvelopeGenerator.Application/Documents/Queries/Read/ReadDocumentResponseBase.cs

@@ -0,0 +1,22 @@
+namespace EnvelopeGenerator.Application.Documents.Queries.Read;
+
+/// <summary>
+/// Represents the response for reading a document.
+/// </summary>
+public class ReadDocumentResponseBase
+{
+    /// <summary>
+    /// The unique identifier of the document.
+    /// </summary>
+    public int Guid { get; init; }
+
+    /// <summary>
+    /// The identifier of the associated envelope.
+    /// </summary>
+    public int EnvelopeId { get; init; }
+
+    /// <summary>
+    /// The date and time when the document was added.
+    /// </summary>
+    public DateTime AddedWhen { get; init; }
+}

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

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

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

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

EnvelopeGenerator.Application/EmailTemplates/EmailTemplateQuery.cs

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

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

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

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

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

EnvelopeGenerator.Application/EnvelopeGenerator.Application.csproj

@@ -1,55 +1,83 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-  </PropertyGroup>
+	<PropertyGroup>
+		<TargetFrameworks>net7.0;net8.0;net9.0</TargetFrameworks>
+		<ImplicitUsings>enable</ImplicitUsings>
+		<Nullable>enable</Nullable>
+		<GenerateDocumentationFile>true</GenerateDocumentationFile>
+		<DocumentationFile>bin\$(Configuration)\$(TargetFramework)\$(AssemblyName).xml</DocumentationFile>
+	</PropertyGroup>
 
-  <ItemGroup>
-    <None Remove="Resources\Model.Designer.vb" />
-  </ItemGroup>
+	<ItemGroup>
+		<None Remove="Resources\Model.Designer.vb" />
+	</ItemGroup>
 
-  <ItemGroup>
-    <PackageReference Include="AutoMapper" Version="13.0.1" />
-    <PackageReference Include="DigitalData.Core.Abstractions" Version="1.0.1.1" />
-    <PackageReference Include="DigitalData.Core.Application" Version="1.0.0" />
-    <PackageReference Include="DigitalData.Core.DTO" Version="1.0.0" />
-    <PackageReference Include="DigitalData.EmailProfilerDispatcher" Version="1.0.0" />
-    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="7.0.18" />
-    <PackageReference Include="UserManager.Application" Version="1.0.0" />
-    <PackageReference Include="UserManager.Infrastructure" Version="1.0.0" />
-  </ItemGroup>
+	<ItemGroup>
+		<PackageReference Include="DigitalData.Core.Abstractions" Version="3.4.3" />
+		<PackageReference Include="DigitalData.Core.Application" Version="3.2.1" />
+		<PackageReference Include="DigitalData.Core.Client" Version="2.0.3" />
+		<PackageReference Include="DigitalData.Core.DTO" Version="2.0.1" />
+		<PackageReference Include="DigitalData.EmailProfilerDispatcher" Version="3.0.0" />
+		<PackageReference Include="MediatR" Version="12.5.0" />
+		<PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="7.0.18" />
+		<PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.4" />
+		<PackageReference Include="Otp.NET" Version="1.4.0" />
+		<PackageReference Include="QRCoder" Version="1.6.0" />
+		<PackageReference Include="QRCoder-ImageSharp" Version="0.10.0" />
+		<PackageReference Include="UserManager" Version="1.0.0" />
+	</ItemGroup>
 
-  <ItemGroup>
-    <ProjectReference Include="..\EnvelopeGenerator.Infrastructure\EnvelopeGenerator.Infrastructure.csproj" />
-  </ItemGroup>
+	<ItemGroup>
+		<ProjectReference Include="..\EnvelopeGenerator.Domain\EnvelopeGenerator.Domain.csproj" />
+		<ProjectReference Include="..\EnvelopeGenerator.Extensions\EnvelopeGenerator.Extensions.csproj" />
+	</ItemGroup>
 
-  <ItemGroup>
-    <Compile Update="Resources\Model.Designer.cs">
-      <DesignTime>True</DesignTime>
-      <AutoGen>True</AutoGen>
-      <DependentUpon>Model.resx</DependentUpon>
-    </Compile>
-  </ItemGroup>
+	<ItemGroup>
+		<Compile Update="Resources\Model.Designer.cs">
+			<DesignTime>True</DesignTime>
+			<AutoGen>True</AutoGen>
+			<DependentUpon>Model.resx</DependentUpon>
+		</Compile>
+	</ItemGroup>
 
-  <ItemGroup>
-    <EmbeddedResource Update="Resources\Model.en.resx">
-      <CustomToolNamespace>My.Resources</CustomToolNamespace>
-      <LastGenOutput>Model.en.Designer.vb</LastGenOutput>
-      <Generator>PublicResXFileCodeGenerator</Generator>
-    </EmbeddedResource>
-    <EmbeddedResource Update="Resources\Model.resx">
-      <CustomToolNamespace>My.Resources</CustomToolNamespace>
-      <LastGenOutput>Model.Designer.cs</LastGenOutput>
-      <Generator>PublicResXFileCodeGenerator</Generator>
-    </EmbeddedResource>
-    <EmbeddedResource Update="Resources\Resource.de-DE.resx">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </EmbeddedResource>
-    <EmbeddedResource Update="Resources\Resource.en-US.resx">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </EmbeddedResource>
-  </ItemGroup>
+	<ItemGroup>
+		<EmbeddedResource Update="Resources\Model.en.resx">
+			<CustomToolNamespace>My.Resources</CustomToolNamespace>
+			<LastGenOutput>Model.en.Designer.vb</LastGenOutput>
+			<Generator>PublicResXFileCodeGenerator</Generator>
+		</EmbeddedResource>
+		<EmbeddedResource Update="Resources\Model.resx">
+			<CustomToolNamespace>My.Resources</CustomToolNamespace>
+			<LastGenOutput>Model.Designer.cs</LastGenOutput>
+			<Generator>PublicResXFileCodeGenerator</Generator>
+		</EmbeddedResource>
+		<EmbeddedResource Update="Resources\Resource.de-DE.resx">
+			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+		</EmbeddedResource>
+		<EmbeddedResource Update="Resources\Resource.en-US.resx">
+			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+		</EmbeddedResource>
+	</ItemGroup>
+
+	<ItemGroup Condition="'$(TargetFramework)' == 'net7.0'">
+	  <PackageReference Include="AutoMapper" Version="13.0.1" />
+	  <PackageReference Include="CommandDotNet">
+		<Version>7.0.5</Version>
+	  </PackageReference>
+	</ItemGroup>
+
+	<ItemGroup Condition="'$(TargetFramework)' == 'net8.0'">
+	  <PackageReference Include="AutoMapper" Version="14.0.0" />
+	  <PackageReference Include="CommandDotNet">
+	    <Version>8.1.1</Version>
+	  </PackageReference>
+	</ItemGroup>
+
+	<ItemGroup Condition="'$(TargetFramework)' == 'net9.0'">
+	  <PackageReference Include="AutoMapper" Version="14.0.0" />
+	  <PackageReference Include="CommandDotNet">
+	    <Version>8.1.1</Version>
+	  </PackageReference>
+	</ItemGroup>
 
 </Project>

EnvelopeGenerator.Application/EnvelopeGeneratorExtensions.cs

@@ -1,148 +0,0 @@
-using Microsoft.Extensions.Logging;
-using System.Text;
-
-namespace EnvelopeGenerator.Application
-{
-    /// <summary>
-    /// Provides extension methods for decoding and extracting information from an envelope receiver ID.
-    /// </summary>
-    public static class EnvelopeGeneratorExtensions
-    {
-        /// <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>
-        /// 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 = System.Text.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>
-        /// 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;
-
-		public static string EncodeEnvelopeReceiverId(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;
-		}
-
-		public static void LogEnvelopeError(this ILogger logger, string envelopeReceiverId, Exception? exception = null, string? message = null, params object?[] args)
-        {
-            var sb = new StringBuilder().AppendLine(envelopeReceiverId.DecodeEnvelopeReceiverId().ToTitle());
-
-            if (message is not null)
-                sb.AppendLine(message);
-
-            if(exception is null)
-                logger.Log(LogLevel.Error, sb.ToString(), args);
-            else
-                logger.Log(LogLevel.Error, exception, sb.AppendLine(exception.Message).ToString(), args);
-        }
-
-        public static void LogEnvelopeError(this ILogger logger, string? uuid, string? signature = null, Exception? exception = null, string? message = null, params object?[] args)
-        {
-            var sb = new StringBuilder($"Envelope Uuid: {uuid}");
-
-            if(signature is not null)
-                sb.AppendLine().Append($"Receiver Signature: {signature}");
-
-            if (message is not null)
-                sb.AppendLine().Append(message);
-
-            if (exception is null)
-                logger.Log(LogLevel.Error, sb.ToString(), args);
-            else
-                logger.Log(LogLevel.Error, exception, sb.ToString(), args);
-        }
-
-        public static string ToTitle(this (string? UUID, string? Signature) envelopeReceiverTuple)
-        {
-            return $"UUID is {envelopeReceiverTuple.UUID} and signature is {envelopeReceiverTuple.Signature}";
-        }
-    }
-}

EnvelopeGenerator.Application/EnvelopeReceivers/Commands/Create/CreateEnvelopeReceiverCommand.cs

@@ -0,0 +1,59 @@
+using MediatR;
+using System.ComponentModel.DataAnnotations;
+
+namespace EnvelopeGenerator.Application.EnvelopeReceivers.Commands.Create;
+
+/// <summary>
+/// Befehl zur Erstellung eines Umschlags.
+/// </summary>
+/// <param name="Title">Der Titel des Umschlags. Dies ist ein Pflichtfeld.</param>
+/// <param name="Message">Die Nachricht, die im Umschlag enthalten sein soll. Dies ist ein Pflichtfeld.</param>
+/// <param name="Document">Das mit dem Umschlag verknüpfte Dokument. Dies ist ein Pflichtfeld.</param>
+/// <param name="Receivers">Eine Sammlung von Empfängern, die den Umschlag erhalten. Dies ist ein Pflichtfeld.</param>
+/// <param name="TFAEnabled">Gibt an, ob die Zwei-Faktor-Authentifizierung für den Umschlag aktiviert ist. Standardmäßig false.</param>
+public record CreateEnvelopeReceiverCommand(
+    [Required] string Title,
+    [Required] string Message,
+    [Required] DocumentCreateCommand Document,
+    [Required] IEnumerable<ReceiverGetOrCreateCommand> Receivers,
+    bool TFAEnabled = false
+    ) : IRequest;
+
+#region DTOs
+/// <summary>
+/// Signaturposition auf einem Dokument.
+/// </summary>
+/// <param name="X">X-Position</param>
+/// <param name="Y">Y-Position</param>
+/// <param name="Page">Seite, auf der sie sich befindet</param>
+public record Signature([Required] int X, [Required] int Y, [Required] int Page);
+
+/// <summary>
+/// DTO für Empfänger, die erstellt oder abgerufen werden sollen.
+/// Wenn nicht, wird sie erstellt und mit einer Signatur versehen.
+/// </summary>
+/// <param name="Signatures">Unterschriften auf Dokumenten.</param>
+/// <param name="Salution">Der Name, mit dem der Empfänger angesprochen werden soll. Bei Null oder keinem Wert wird der zuletzt verwendete Name verwendet.</param>
+/// <param name="PhoneNumber">Sollte mit Vorwahl geschrieben werden</param>
+public record ReceiverGetOrCreateCommand([Required] IEnumerable<Signature> Signatures, string? Salution = null, string? PhoneNumber = null)
+{
+    private string _emailAddress = string.Empty;
+
+    /// <summary>
+    /// E-Mail-Adresse des Empfängers.
+    /// </summary>
+    [Required]
+    public required string EmailAddress { get => _emailAddress.ToLower(); init => _emailAddress = _emailAddress.ToLower(); }
+};
+
+/// <summary>
+/// DTO zum Erstellen eines Dokuments.
+/// </summary>
+/// <param name="DataAsByte">
+/// Die Dokumentdaten im Byte-Array-Format. Wird verwendet, wenn das Dokument als Roh-Binärdaten bereitgestellt wird.
+/// </param>
+/// <param name="DataAsBase64">
+/// Die Dokumentdaten im Base64-String-Format. Wird verwendet, wenn das Dokument als Base64-codierter String bereitgestellt wird.
+/// </param>
+public record DocumentCreateCommand(byte[]? DataAsByte = null, string? DataAsBase64 = null);
+#endregion

EnvelopeGenerator.Application/EnvelopeReceivers/EnvelopeReceiverQuery.cs

@@ -0,0 +1,47 @@
+using EnvelopeGenerator.Application.Histories;
+
+namespace EnvelopeGenerator.Application.EnvelopeReceivers;
+
+/// <summary>
+/// Stellt eine Abfrage für einen Envelope-Empfänger dar.
+/// </summary>
+/// <param name="Status">Der Status der Abfrage, optional.</param>
+public record EnvelopeReceiverQuery(EnvelopeStatusQuery? Status = null);
+
+/// <summary>
+/// Repräsentiert den Status eines Umschlags und dessen Beziehung zum Empfänger. (vgl. auch <see cref="Common.Constants.EnvelopeStatus"/>
+/// Invalid (0): Ungültiger Status.
+/// EnvelopeCreated (1001): Der Umschlag wurde erstellt.
+/// EnvelopeSaved (1002): Der Umschlag wurde gespeichert.
+/// EnvelopeQueued (1003): Der Umschlag wurde zur Verarbeitung eingeplant.
+/// EnvelopeSent (1004): Der Umschlag wurde versendet. (Nicht verwendet)
+/// EnvelopePartlySigned (1005): Der Umschlag wurde teilweise unterschrieben.
+/// EnvelopeCompletelySigned (1006): Der Umschlag wurde vollständig unterschrieben.
+/// EnvelopeReportCreated (1007): Ein Abschlussbericht wurde für den Umschlag erstellt.
+/// EnvelopeArchived (1008): Der Umschlag wurde archiviert.
+/// EnvelopeDeleted (1009): Der Umschlag wurde gelöscht.
+/// AccessCodeRequested (2001): Der Zugriffscode wurde angefordert.
+/// AccessCodeCorrect (2002): Der Zugriffscode war korrekt.
+/// AccessCodeIncorrect (2003): Der Zugriffscode war falsch.
+/// DocumentOpened (2004): Das Dokument wurde geöffnet.
+/// DocumentSigned (2005): Ein Dokument wurde unterschrieben.
+/// SignatureConfirmed (2006): Die Signatur wurde bestätigt.
+/// DocumentRejected (2007): Ein Dokument wurde abgelehnt.
+/// EnvelopeShared (2008): Der Umschlag wurde geteilt.
+/// EnvelopeViewed (2009): Der Umschlag wurde angesehen.
+/// DocumentForwarded (4001): Das Dokument wurde weitergeleitet.
+/// MessageInvitationSent (3001): Einladung wurde gesendet (vom Trigger verwendet).
+/// MessageAccessCodeSent (3002): Zugriffscode wurde gesendet.
+/// MessageConfirmationSent (3003): Bestätigungsnachricht wurde gesendet.
+/// MessageDeletionSent (3004): Löschbenachrichtigung wurde gesendet.
+/// MessageCompletionSent (3005): Abschlussbenachrichtigung wurde gesendet.
+/// <param name="Min">Der minimale Statuswert, der berücksichtigt werden soll.</param>
+/// <param name="Max">Der maximale Statuswert, der berücksichtigt werden soll.</param>
+/// <param name="Ignore">Eine Liste von Statuswerten, die ignoriert werden sollen.</param>
+/// </summary>
+public record EnvelopeStatusQuery(
+    int? Min = null,
+    int? Max = null,
+    int[]? Ignore = null)
+{
+}

EnvelopeGenerator.Application/EnvelopeReceivers/Queries/Read/ReadEnvelopeReceiverQuery.cs

@@ -0,0 +1,30 @@
+using EnvelopeGenerator.Application.Histories;
+using EnvelopeGenerator.Application.Envelopes.Queries.Read;
+using EnvelopeGenerator.Application.Receivers.Queries.Read;
+using MediatR;
+
+namespace EnvelopeGenerator.Application.EnvelopeReceivers.Queries.Read;
+
+/// <summary>
+/// Repräsentiert eine Abfrage zum Lesen eines Envelope-Empfängers.
+/// </summary>
+/// <remarks>
+/// Diese Abfrage kombiniert Informationen über einen Umschlag (<see cref="ReadEnvelopeQuery"/>) 
+/// und einen Empfänger (<see cref="ReadReceiverQuery"/>), um eine vollständige Antwort 
+/// (<see cref="ReadEnvelopeReceiverResponse"/>) zu generieren. 
+/// Die Antwort enthält Details wie den Status, die Zuordnung zwischen Umschlag und Empfänger 
+/// sowie zusätzliche Metadaten.
+/// </remarks>
+/// <param name="Status">Umschlag oder Empfängerstatus.</param>
+public record ReadEnvelopeReceiverQuery(EnvelopeStatusQuery? Status = null) : EnvelopeReceiverQuery(Status), IRequest<ReadEnvelopeReceiverResponse>
+{
+    /// <summary>
+    /// Der Umschlag, der mit dem Empfänger verknüpft ist.
+    /// </summary>
+    public ReadEnvelopeQuery? Envelope { get; init; }
+
+    /// <summary>
+    /// Der Empfänger, der mit dem Umschlag verknüpft ist.
+    /// </summary>
+    public ReadReceiverQuery? Receiver { get; init; }
+};

EnvelopeGenerator.Application/EnvelopeReceivers/Queries/Read/ReadEnvelopeReceiverResponse.cs

@@ -0,0 +1,94 @@
+using DigitalData.EmailProfilerDispatcher.Abstraction.Attributes;
+using EnvelopeGenerator.Application.Envelopes.Queries.Read;
+using EnvelopeGenerator.Application.Receivers.Queries.Read;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace EnvelopeGenerator.Application.EnvelopeReceivers.Queries.Read;
+
+/// <summary>
+/// Repräsentiert die Antwort für das Lesen eines Envelope-Empfängers.
+/// </summary>
+/// <remarks>
+/// Diese Klasse enthält Informationen über einen spezifischen Empfänger eines Umschlags (Envelope).
+/// Sie verknüpft die Empfängerinformationen mit den zugehörigen Umschlagsdaten und bietet zusätzliche Metadaten.
+/// </remarks>
+/// <param name="UserId">Die eindeutige Kennung des Benutzers, der den Empfänger erstellt hat.</param>
+/// <param name="Status">Der Status des Empfängers als numerischer Wert.</param>
+public record ReadEnvelopeReceiverResponse(int UserId, int Status)
+{
+    /// <summary>
+    /// Gibt die zusammengesetzte Kennung des Empfängers zurück, bestehend aus der Umschlags-ID und der Empfänger-ID.
+    /// </summary>
+    /// <remarks>
+    /// Diese Eigenschaft kombiniert die eindeutige Kennung des Umschlags (EnvelopeId) und die des Empfängers (ReceiverId) 
+    /// zu einer einzigen, leicht zugänglichen Struktur.
+    /// </remarks>
+    [NotMapped]
+    public (int Envelope, int Receiver) Id => (Envelope: EnvelopeId, Receiver: ReceiverId);
+
+    /// <summary>
+    /// Die eindeutige Kennung des zugehörigen Umschlags.
+    /// </summary>
+    [Required]
+    public int EnvelopeId { get; init; }
+
+    /// <summary>
+    /// Die eindeutige Kennung des Empfängers.
+    /// </summary>
+    [Required]
+    public int ReceiverId { get; init; }
+
+    /// <summary>
+    /// Die Reihenfolge des Empfängers innerhalb des Umschlags.
+    /// </summary>
+    public int Sequence { get; init; }
+
+    /// <summary>
+    /// Der Name des Empfängers. Kann als Platzhalter verwendet werden.
+    /// </summary>
+    [TemplatePlaceholder("[NAME_RECEIVER]")]
+    public string? Name { get; init; }
+
+    /// <summary>
+    /// Die Berufsbezeichnung des Empfängers.
+    /// </summary>
+    public string? JobTitle { get; init; }
+
+    /// <summary>
+    /// Der Firmenname des Empfängers.
+    /// </summary>
+    public string? CompanyName { get; init; }
+
+    /// <summary>
+    /// Eine private Nachricht, die mit dem Empfänger verknüpft ist.
+    /// </summary>
+    public string? PrivateMessage { get; init; }
+
+    /// <summary>
+    /// Das Datum und die Uhrzeit, wann der Empfänger hinzugefügt wurde.
+    /// </summary>
+    public DateTime AddedWhen { get; init; }
+
+    /// <summary>
+    /// Das Datum und die Uhrzeit, wann der Empfänger zuletzt geändert wurde (falls vorhanden).
+    /// </summary>
+    public DateTime? ChangedWhen { get; init; }
+
+    /// <summary>
+    /// Gibt an, ob der Empfänger eine Telefonnummer hat.
+    /// </summary>
+    public bool HasPhoneNumber { get; init; }
+
+    /// <summary>
+    /// Die zugehörigen Umschlagsdaten.
+    /// </summary>
+    [Required]
+    public required ReadEnvelopeResponse Envelope { get; init; }
+
+    /// <summary>
+    /// Die Liste der Empfängerinformationen.
+    /// </summary>
+    [Required]
+    public IEnumerable<ReadReceiverResponse> Receiver { get; init; } = new List<ReadReceiverResponse>();
+}

EnvelopeGenerator.Application/Envelopes/EnvelopeQuery.cs

@@ -0,0 +1,16 @@
+using MediatR;
+
+namespace EnvelopeGenerator.Application.Envelopes;
+
+/// <summary>
+/// Repräsentiert eine Abfrage für Umschläge.
+/// </summary>
+/// <param name="Id">Die eindeutige Kennung des Umschlags.</param>
+/// <param name="Status">Der Status des Umschlags.</param>
+/// <param name="Uuid">Die universell eindeutige Kennung des Umschlags.</param>
+public record EnvelopeQuery(
+    int? Id = null,
+    int? Status = null,
+    string? Uuid = null) : IRequest
+{
+};

EnvelopeGenerator.Application/Envelopes/Queries/Read/ReadEnvelopeQuery.cs

@@ -0,0 +1,8 @@
+namespace EnvelopeGenerator.Application.Envelopes.Queries.Read;
+
+/// <summary>
+/// Stellt eine Abfrage zum Lesen von Briefumschlägen dar.
+/// </summary>
+public record ReadEnvelopeQuery : EnvelopeQuery
+{
+}

EnvelopeGenerator.Application/Envelopes/Queries/Read/ReadEnvelopeResponse.cs

@@ -0,0 +1,36 @@
+using EnvelopeGenerator.Common;
+
+namespace EnvelopeGenerator.Application.Envelopes.Queries.Read;
+
+/// <summary>
+/// Repräsentiert die Antwort für das Lesen eines Umschlags.
+/// </summary>
+/// <param name="Id">Die eindeutige Kennung des Umschlags.</param>
+/// <param name="UserId">Die Kennung des Benutzers, der den Umschlag erstellt hat.</param>
+/// <param name="Status">Der Status des Umschlags als numerischer Wert.</param>
+/// <param name="Uuid">Die universelle eindeutige Kennung (UUID) des Umschlags.</param>
+/// <param name="Message">Eine optionale Nachricht, die mit dem Umschlag verknüpft ist.</param>
+/// <param name="AddedWhen">Das Datum und die Uhrzeit, wann der Umschlag hinzugefügt wurde.</param>
+/// <param name="ChangedWhen">Das Datum und die Uhrzeit, wann der Umschlag zuletzt geändert wurde (falls vorhanden).</param>
+/// <param name="Title">Ein optionaler Titel des Umschlags.</param>
+/// <param name="Language">Die Sprache, die mit dem Umschlag verknüpft ist.</param>
+/// <param name="TFAEnabled">Gibt an, ob die Zwei-Faktor-Authentifizierung (TFA) aktiviert ist.</param>
+/// <param name="User">Das Benutzerobjekt, das mit dem Umschlag verknüpft ist.</param>
+public record ReadEnvelopeResponse(
+    int Id,
+    int UserId,
+    int Status,
+    string Uuid,
+    string? Message,
+    DateTime AddedWhen,
+    DateTime? ChangedWhen,
+    string? Title,
+    string Language,
+    bool TFAEnabled,
+    DigitalData.UserManager.Domain.Entities.User User)
+{
+    /// <summary>
+    /// Gibt den Namen des Status zurück, der dem numerischen Statuswert entspricht.
+    /// </summary>
+    public string StatusName => ((Constants.EnvelopeStatus)Status).ToString();
+}

EnvelopeGenerator.Application/Envelopes/Queries/ReceiverName/ReadReceiverNameQuery.cs

@@ -0,0 +1,13 @@
+using EnvelopeGenerator.Application.Receivers.Queries.Read;
+
+namespace EnvelopeGenerator.Application.Envelopes.Queries.ReceiverName;
+
+/// <summary>
+/// Eine Abfrage, um die zuletzt verwendete Anrede eines Empfängers zu ermitteln, 
+/// damit diese für zukünftige Umschläge wiederverwendet werden kann.
+/// </summary>
+/// <param name="Envelope">Der Umschlag, für den die Anrede des Empfängers ermittelt werden soll.</param>
+/// <param name="OnlyLast">Gibt an, ob nur die zuletzt verwendete Anrede zurückgegeben werden soll.</param>
+public record ReadReceiverNameQuery(EnvelopeQuery? Envelope = null, bool OnlyLast = true) : ReadReceiverQuery
+{
+}

EnvelopeGenerator.Application/Extensions/CacheExtensions.cs

@@ -0,0 +1,131 @@
+using Microsoft.Extensions.Caching.Distributed;
+
+namespace EnvelopeGenerator.Application.Extensions
+{
+    public static class CacheExtensions
+    {
+        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);
+
+        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);
+        }
+
+        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);
+
+        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));
+        }
+
+        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);
+
+        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
+        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;
+        }
+
+        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
+        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;
+            }
+        }
+
+        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/Extensions/MappingExtensions.cs

@@ -0,0 +1,14 @@
+using EnvelopeGenerator.Application.DTOs.Messaging;
+
+namespace EnvelopeGenerator.Application.Extensions
+{
+    public static class MappingExtensions
+    {
+        public static bool Ok(this GtxMessagingResponse gtxMessagingResponse)
+            => gtxMessagingResponse.TryGetValue("message-status", out var status)
+            && status?.ToString()?.ToLower() == "ok";
+
+        public static string ToBase64String(this byte[] bytes)
+            => Convert.ToBase64String(bytes);
+    }
+}