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

@@ -360,4 +360,8 @@ MigrationBackup/
 .ionide/
 
 # Fody - auto-generated XML schema
-FodyWeavers.xsd
+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/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/DTOs/ConfigDto.cs

@@ -0,0 +1,21 @@
+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) : 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

@@ -0,0 +1,26 @@
+using DigitalData.Core.Abstractions;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.DTOs
+{
+    [ApiExplorerSettings(IgnoreApi = true)]
+    public record DocumentReceiverElementDto(
+        int Id,
+        int DocumentId,
+        int ReceiverId,
+        int ElementType,
+        double X,
+        double Y,
+        double Width,
+        double Height,
+        int Page,
+        bool Required,
+        string? Tooltip,
+        bool ReadOnly,
+        int AnnotationIndex,
+        DateTime AddedWhen,
+        DateTime? ChangedWhen,
+        double Top,
+        double Left
+        ): IUnique<int>;
+}

EnvelopeGenerator.Application/DTOs/DocumentStatusDto.cs

@@ -0,0 +1,18 @@
+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,
+        DateTime AddedWhen,
+        DateTime? ChangedWhen) : IUnique<int>
+    {
+        public string? Value { get; set; }
+    };
+}

EnvelopeGenerator.Application/DTOs/EmailTemplateDto.cs

@@ -0,0 +1,12 @@
+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) : IUnique<int>;
+}

EnvelopeGenerator.Application/DTOs/EnvelopeCertificateDto.cs

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

EnvelopeGenerator.Application/DTOs/EnvelopeDocumentDto.cs

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

EnvelopeGenerator.Application/DTOs/EnvelopeDto.cs

@@ -0,0 +1,71 @@
+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
+{
+    [ApiExplorerSettings(IgnoreApi = true)]
+    public record EnvelopeDto() : IUnique<int>
+    {
+		public int Id { get; set; }
+
+		public int UserId { get; set; }
+
+		public int Status { get; set; }
+
+		public string StatusName { get; set; }
+
+        public string Uuid { get; set; }
+
+		[TemplatePlaceholder("[MESSAGE]")]
+		public string Message { get; set; }
+		public DateTime? ExpiresWhen { get; set; }
+		public DateTime? ExpiresWarningWhen { get; set; }
+		public DateTime AddedWhen { get; set; }
+		public DateTime? ChangedWhen { get; set; }
+
+		[TemplatePlaceholder("[DOCUMENT_TITLE]")]
+		public string Title { get; set; }
+
+		public int? ContractType { get; set; }
+
+		public string Language { get; set; }
+
+		public bool? SendReminderEmails { get; set; }
+
+		public int? FirstReminderDays { get; set; }
+
+		public int? ReminderIntervalDays { get; set; }
+
+		public int? EnvelopeTypeId { get; set; }
+
+		public int? CertificationType { get; set; }
+
+		public bool? UseAccessCode { get; set; }
+
+		public int? FinalEmailToCreator { get; set; }
+
+		public int? FinalEmailToReceivers { get; set; }
+
+		public int? ExpiresWhenDays { get; set; }
+
+		public int? ExpiresWarningWhenDays { get; set; }
+
+        public bool TFAEnabled { get; init; }
+
+        public bool DmzMoved { get; set; }
+		public UserReadDto? User { get; set; }
+		public EnvelopeType? EnvelopeType { get; set; }
+
+		public string? EnvelopeTypeTitle { get; set; }
+
+		public bool IsAlreadySent { get; set; }
+
+		public string? StatusTranslated { get; set; }
+
+		public string? ContractTypeTranslated { get; set; }
+		public IEnumerable<EnvelopeDocumentDto>? Documents { get; set; }
+	}
+}

EnvelopeGenerator.Application/DTOs/EnvelopeHistory/EnvelopeHistoryCreateDto.cs

@@ -0,0 +1,12 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.DTOs.EnvelopeHistory
+{
+    [ApiExplorerSettings(IgnoreApi = true)]
+    public record EnvelopeHistoryCreateDto(
+        int EnvelopeId,
+        string UserReference,
+        int Status,
+        DateTime? ActionDate,
+        string? Comment = null);
+}

EnvelopeGenerator.Application/DTOs/EnvelopeHistory/EnvelopeHistoryDto.cs

@@ -0,0 +1,23 @@
+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), 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/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

@@ -0,0 +1,23 @@
+using DigitalData.Core.Abstractions;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.DTOs
+{
+    [ApiExplorerSettings(IgnoreApi = true)]
+    public record EnvelopeTypeDto(
+        int Id,
+        string Title,
+        string Language,
+        int? ExpiresDays,
+        int? CertificationType,
+        bool? UseAccessCode,
+        int? FinalEmailToCreator,
+        int? FinalEmailToReceivers,
+        DateTime AddedWhen,
+        DateTime? ChangedWhen,
+        int? ExpiresWarningDays,
+        bool? SendReminderEmails,
+        int? FirstReminderDays,
+        int? ReminderIntervalDays,
+        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

@@ -0,0 +1,23 @@
+using Microsoft.AspNetCore.Mvc;
+using System.ComponentModel.DataAnnotations;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace EnvelopeGenerator.Application.DTOs.Receiver
+{
+    [ApiExplorerSettings(IgnoreApi = true)]
+    public record ReceiverCreateDto([EmailAddress] string EmailAddress, string? TotpSecretkey = null)
+    {
+        public string Signature => sha256HexOfMail.Value;
+
+        private readonly Lazy<string> sha256HexOfMail = new(() =>
+        {
+            var bytes_arr = Encoding.UTF8.GetBytes(EmailAddress.ToUpper());
+            var hash_arr = SHA256.HashData(bytes_arr);
+            var hexa_str = BitConverter.ToString(hash_arr);
+            return hexa_str.Replace("-", string.Empty);
+        });
+
+        public DateTime AddedWhen { get; } = DateTime.Now;
+    };
+}

EnvelopeGenerator.Application/DTOs/Receiver/ReceiverReadDto.cs

@@ -0,0 +1,26 @@
+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;
+
+[ApiExplorerSettings(IgnoreApi = true)]
+public record ReceiverReadDto(
+    int Id,
+    string EmailAddress,
+    string Signature,
+    DateTime AddedWhen
+    ) : BaseDTO<int>(Id), IUnique<int>
+{
+    [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

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

@@ -0,0 +1,15 @@
+using DigitalData.Core.Abstractions;
+using Microsoft.AspNetCore.Mvc;
+
+namespace EnvelopeGenerator.Application.DTOs
+{
+    [ApiExplorerSettings(IgnoreApi = true)]
+    public record UserReceiverDto(
+        int Id,
+        int UserId,
+        int ReceiverId,
+        string Name,
+        string CompanyName,
+        string JobTitle,
+        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/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/EnvelopeFlag.cs

@@ -0,0 +1,10 @@
+namespace EnvelopeGenerator.Application
+{
+    public enum EnvelopeFlag
+    {
+        EnvelopeOrReceiverNonexists,
+        NonDecodableEnvelopeReceiverId,
+        WrongEnvelopeReceiverId,
+        AccessCodeNull
+    }
+}

EnvelopeGenerator.Application/EnvelopeGenerator.Application.csproj

@@ -0,0 +1,83 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<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>
+		<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.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>
+		<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/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);
+    }
+}

EnvelopeGenerator.Application/Histories/Queries/Read/ReadHistoryQuery.cs

@@ -0,0 +1,20 @@
+using EnvelopeGenerator.Application.Envelopes.Queries.Read;
+using EnvelopeGenerator.Application.Receivers.Queries.Read;
+using EnvelopeGenerator.Common;
+
+namespace EnvelopeGenerator.Application.Histories.Queries.Read;
+
+/// <summary>
+/// Repräsentiert eine Abfrage für die Verlaufshistorie eines Umschlags.
+/// </summary>
+/// <param name="EnvelopeId">Die eindeutige Kennung des Umschlags.</param>
+/// <param name="Envelope">Die Abfrage, die den Umschlag beschreibt.</param>
+/// <param name="Receiver">Die Abfrage, die den Empfänger beschreibt.</param>
+/// <param name="Related">Abfrage, die angibt, worauf sich der Datensatz bezieht. Ob er sich auf den Empfänger, den Sender oder das System bezieht, wird durch 0, 1 bzw. 2 dargestellt.</param>
+/// <param name="OnlyLast">Abfrage zur Steuerung, ob nur der aktuelle Status oder der gesamte Datensatz zurückgegeben wird.</param>
+public record ReadHistoryQuery(
+    int EnvelopeId,
+    ReadEnvelopeQuery? Envelope = null,
+    ReadReceiverQuery? Receiver = null,
+    Constants.ReferenceType? Related = null,
+    bool? OnlyLast = true);

EnvelopeGenerator.Application/Key.cs

@@ -0,0 +1,20 @@
+namespace EnvelopeGenerator.Application
+{
+    public static class Key
+    {
+        public static readonly string InnerServiceError = nameof(InnerServiceError);
+        public static readonly string EnvelopeNotFound = nameof(EnvelopeNotFound);
+        public static readonly string EnvelopeReceiverNotFound = nameof(EnvelopeReceiverNotFound);
+        public static readonly string AccessCodeNull = nameof(AccessCodeNull);
+        public static readonly string WrongAccessCode = nameof(WrongAccessCode);
+        public static readonly string DataIntegrityIssue = nameof(DataIntegrityIssue);
+        public static readonly string SecurityBreachOrDataIntegrity = nameof(SecurityBreachOrDataIntegrity);
+        public static readonly string PossibleDataIntegrityIssue = nameof(PossibleDataIntegrityIssue);
+        public static readonly string SecurityBreach = nameof(SecurityBreach);
+        public static readonly string PossibleSecurityBreach = nameof(PossibleSecurityBreach);
+        public static readonly string WrongEnvelopeReceiverId = nameof(WrongEnvelopeReceiverId);
+        public static readonly string EnvelopeOrReceiverNonexists = nameof(EnvelopeOrReceiverNonexists);
+        public static readonly string PhoneNumberNonexists = nameof(PhoneNumberNonexists);
+        public static readonly string Default = nameof(Default);
+    }
+}

EnvelopeGenerator.Application/Receivers/Queries/Read/ReadReceiverQuery.cs

@@ -0,0 +1,10 @@
+namespace EnvelopeGenerator.Application.Receivers.Queries.Read;
+
+/// <summary>
+/// Stellt eine Abfrage dar, um die Details eines Empfängers zu lesen.
+/// Diese Abfrage erbt von <see cref="ReceiverQuery"/> und wird verwendet, 
+/// um spezifische Informationen über einen Empfänger abzurufen.
+/// </summary>
+public record ReadReceiverQuery : ReceiverQuery
+{
+}

EnvelopeGenerator.Application/Receivers/Queries/Read/ReadReceiverResponse.cs

@@ -0,0 +1,12 @@
+namespace EnvelopeGenerator.Application.Receivers.Queries.Read;
+
+/// <summary>
+/// Repräsentiert die Antwort auf eine Abfrage, um einen Empfänger zu lesen.
+/// </summary>
+/// <param name="Id">Die eindeutige Identifikationsnummer des Empfängers.</param>
+/// <param name="EmailAddress">Die E-Mail-Adresse des Empfängers.</param>
+/// <param name="AddedWhen">Das Datum und die Uhrzeit, wann der Empfänger hinzugefügt wurde.</param>
+/// <param name="Signature">Die Signatur des Empfängers.</param>
+public record ReadReceiverResponse(int Id, string EmailAddress, DateTime AddedWhen, string Signature)
+{
+}

EnvelopeGenerator.Application/Receivers/ReceiverQuery.cs

@@ -0,0 +1,9 @@
+namespace EnvelopeGenerator.Application.Receivers;
+
+/// <summary>
+/// Empfänger des Umschlags
+/// </summary>
+/// <param name="Id">ID des Empfängers</param>
+/// <param name="EmailAddress">E-Mail Adresse des Empfängers</param>
+/// <param name="Signature">Eindeutige Signatur des Empfängers</param>
+public record ReceiverQuery(int? Id = null, string? EmailAddress = null, string? Signature = null);

EnvelopeGenerator.Application/Resources/Resource.cs

@@ -0,0 +1,9 @@
+namespace EnvelopeGenerator.Application.Resources
+{
+    /// <summary>
+    /// The place holder class for Resource.*.resx
+    /// </summary>
+    public class Resource
+    {
+    }
+}

EnvelopeGenerator.Application/Resources/Resource.de-DE.resx

@@ -0,0 +1,261 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="and" xml:space="preserve">
+    <value>und</value>
+  </data>
+  <data name="Back" xml:space="preserve">
+    <value>Zurück</value>
+  </data>
+  <data name="Complete" xml:space="preserve">
+    <value>Abschließen</value>
+  </data>
+  <data name="Confirmation" xml:space="preserve">
+    <value>Bestätigung</value>
+  </data>
+  <data name="de-DE" xml:space="preserve">
+    <value>Deutch</value>
+  </data>
+  <data name="DocProtected" xml:space="preserve">
+    <value>Dokument geschützt</value>
+  </data>
+  <data name="DocRejected" xml:space="preserve">
+    <value>Dokument abgelehnt</value>
+  </data>
+  <data name="DocSigned" xml:space="preserve">
+    <value>Dokument unterschrieben</value>
+  </data>
+  <data name="en-US" xml:space="preserve">
+    <value>Englisch</value>
+  </data>
+  <data name="EnvelopeInfo1" xml:space="preserve">
+    <value>Sie müssen {0} Vorgang unterzeichen. &lt;span class="highlight highlight-envelope-info-1"&gt;Bitte prüfen Sie die Seite {1}&lt;/span&gt;.</value>
+  </data>
+  <data name="EnvelopeInfo2" xml:space="preserve">
+    <value>Erstellt am {0} von {1}. Sie können den Absender über &lt;span class="highlight highlight-envelope-info-2"&gt;&lt;a class="mail-link" href="mailto:{2}?subject={3}&amp;body=Sehr%20geehrter%20{4}%20{5},%0A%0A%0A"&gt;{6}&lt;/a&gt;&lt;/span&gt; kontaktieren.</value>
+  </data>
+  <data name="Finalize" xml:space="preserve">
+    <value>Abschließen</value>
+  </data>
+  <data name="Hello" xml:space="preserve">
+    <value>Hallo</value>
+  </data>
+  <data name="HomePageDescription" xml:space="preserve">
+    <value>Das digitale Unterschriftenportal ist eine Plattform, die entwickelt wurde, um Ihre Dokumente sicher zu unterschreiben und zu verwalten. Mit seiner benutzerfreundlichen Oberfläche können Sie Ihre Dokumente schnell hochladen, die Unterschriftsprozesse verfolgen und Ihre digitalen Unterschriftenanwendungen einfach durchführen. Dieses Portal beschleunigt Ihren Arbeitsablauf mit rechtlich gültigen Unterschriften und erhöht gleichzeitig die Sicherheit Ihrer Dokumente.</value>
+  </data>
+  <data name="LocationWarning" xml:space="preserve">
+    <value>Bitte überprüfen Sie die Standortinformationen. Wenn sie falsch sind, korrigieren Sie diese bitte.</value>
+  </data>
+  <data name="LockedBodyAccess" xml:space="preserve">
+    <value>Wir senden Ihnen nun einen Zugriffscode an Ihre hinterlegte Email-Adresse. Dies kann evtl. einige Minuten dauern!</value>
+  </data>
+  <data name="LockedBodyAuthenticator" xml:space="preserve">
+    <value>Bitte geben Sie den in Ihrer Authenticator-App angegebenen TOTP-Code ein.</value>
+  </data>
+  <data name="LockedBodyAuthenticatorNew" xml:space="preserve">
+    <value>Wir haben den QR-Code an Ihre E-Mail-Adresse gesendet. Ihr QR-Code ist bis {0} gültig. Sie können ihn für alle Umschläge verwenden, die Sie an diese E-Mail-Adresse erhalten.</value>
+  </data>
+  <data name="LockedBodySms" xml:space="preserve">
+    <value>Wir haben soeben den Zugangscode als SMS an die von Ihnen angegebene Telefonnummer gesendet.</value>
+  </data>
+  <data name="LockedCodeLabelAccess" xml:space="preserve">
+    <value>Zugriffscode</value>
+  </data>
+  <data name="LockedCodeLabelAuthenticator" xml:space="preserve">
+    <value>TOTP</value>
+  </data>
+  <data name="LockedCodeLabelSms" xml:space="preserve">
+    <value>SMS-Code</value>
+  </data>
+  <data name="LockedFooterBodyAccess" xml:space="preserve">
+    <value>Bitte überprüfen Sie Ihr Email Postfach inklusive Spam-Ordner. Sie können auch den Absender &lt;a class="mail-link" href="mailto:{0}?subject={1}&amp;body={2}" target="_blank"&gt;{0}&lt;/a&gt; bitten, Ihnen den Code auf anderem Wege zukommen zu lassen.</value>
+  </data>
+  <data name="LockedFooterBodyAuthenticator" xml:space="preserve">
+    <value>Der neue QR-Code wird nur einmal für einen bestimmten Zeitraum gesendet und nach dem Scannen in Ihrer Authenticator-App gespeichert. Er kann für alle Umschläge verwendet werden, die an dieselbe E-Mail-Adresse gesendet werden, bis er abläuft. Wenn Sie die QR-Code-Mail nicht erhalten oder sie sowohl aus der Mail als auch aus authenticator löschen, kontaktieren Sie bitte den Absender.</value>
+  </data>
+  <data name="LockedFooterBodySms" xml:space="preserve">
+    <value>Sie können den Absender bitten, Ihre Rufnummer zu überprüfen. Die Telefonnummer muss mit der Ortsvorwahl eingegeben werden. Andernfalls können Sie beantragen, den Zwei-Faktor-Schutz zu entfernen.</value>
+  </data>
+  <data name="LockedFooterTitleAccess" xml:space="preserve">
+    <value>Sie haben keinen Zugriffscode erhalten?</value>
+  </data>
+  <data name="LockedFooterTitleAuthenticator" xml:space="preserve">
+    <value>Sie haben keinen QR-Code erhalten?</value>
+  </data>
+  <data name="LockedFooterTitleSms" xml:space="preserve">
+    <value>Sie haben keine SMS erhalten?</value>
+  </data>
+  <data name="LockedTitleAccess" xml:space="preserve">
+    <value>Dokument erfordert einen Zugriffscode</value>
+  </data>
+  <data name="LockedTitleAuthenticator" xml:space="preserve">
+    <value>2-Faktor-Authentifizierung</value>
+  </data>
+  <data name="LockedTitleSms" xml:space="preserve">
+    <value>2-Faktor-Authentifizierung</value>
+  </data>
+  <data name="Privacy" xml:space="preserve">
+    <value>Datenschutz</value>
+  </data>
+  <data name="ReadOnlyMessage" xml:space="preserve">
+    <value>Weitergeleitet von {0}. Gültig bis {1}.</value>
+  </data>
+  <data name="Reject" xml:space="preserve">
+    <value>Ablehnen</value>
+  </data>
+  <data name="Rejection" xml:space="preserve">
+    <value>Ablehnung</value>
+  </data>
+  <data name="RejectionInfo1" xml:space="preserve">
+    <value>Dieser Unterzeichnungsvorgang wurde abgelehnt!</value>
+  </data>
+  <data name="RejectionInfo1_ext" xml:space="preserve">
+    <value>Vorgang abgebrochen!</value>
+  </data>
+  <data name="RejectionInfo2" xml:space="preserve">
+    <value>Sie können bei Bedarf mit {0}, &lt;a href="mailto:{1}?subject={2}&amp;body=Sehr geehrte(r)%20{0},%0A%0A%0A"&gt;{1}&lt;/a&gt; Kontakt aufnehmen.</value>
+  </data>
+  <data name="RejectionInfo2_ext" xml:space="preserve">
+    <value>Das Vorgang wurde von einer der beteiligten Parteien abgelehnt. Sie können bei Bedarf mit {0}, &lt;a href="mailto:{1}?subject={2}&amp;body=Sehr geehrte(r)%20{0},%0A%0A%0A"&gt;{1}&lt;/a&gt; Kontakt aufnehmen.</value>
+  </data>
+  <data name="RejectionReasonQ" xml:space="preserve">
+    <value>Bitte geben Sie einen Grund an:</value>
+  </data>
+  <data name="SigAgree" xml:space="preserve">
+    <value>Durch Klick auf Abschließen stimme ich zu, dass die abgebildete und übermittelte Signatur als elektronische Darstellung meiner Signatur in den Fällen gelten, in denen ich sie auf Dokumenten, einschließlich rechtsgültiger Verträge verwende.</value>
+  </data>
+  <data name="SignDoc" xml:space="preserve">
+    <value>Dokument unterschreiben</value>
+  </data>
+  <data name="SigningProcessTitle" xml:space="preserve">
+    <value>Titel des Unterzeichnungs-Vorgangs</value>
+  </data>
+  <data name="UnexpectedError" xml:space="preserve">
+    <value>Ein unerwarteter Fehler ist aufgetreten.</value>
+  </data>
+  <data name="ViewDoc" xml:space="preserve">
+    <value>Dokument ansehen</value>
+  </data>
+  <data name="WelcomeToTheESignPortal" xml:space="preserve">
+    <value>Herzlich willkommen im eSign-Portal</value>
+  </data>
+  <data name="WrongAccessCode" xml:space="preserve">
+    <value>Ungültiger Zugangscode.</value>
+  </data>
+</root>

EnvelopeGenerator.Application/Resources/Resource.en-US.resx

@@ -0,0 +1,261 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="and" xml:space="preserve">
+    <value>and</value>
+  </data>
+  <data name="Back" xml:space="preserve">
+    <value>Back</value>
+  </data>
+  <data name="Complete" xml:space="preserve">
+    <value>Complete</value>
+  </data>
+  <data name="Confirmation" xml:space="preserve">
+    <value>Confirmation</value>
+  </data>
+  <data name="de-DE" xml:space="preserve">
+    <value>German</value>
+  </data>
+  <data name="DocProtected" xml:space="preserve">
+    <value>Document protected</value>
+  </data>
+  <data name="DocRejected" xml:space="preserve">
+    <value>Document rejected</value>
+  </data>
+  <data name="DocSigned" xml:space="preserve">
+    <value>Document signed</value>
+  </data>
+  <data name="en-US" xml:space="preserve">
+    <value>English</value>
+  </data>
+  <data name="EnvelopeInfo1" xml:space="preserve">
+    <value>You have to sign {0} process. &lt;span class="highlight highlight-envelope-info-1"&gt;Please check page {1}&lt;/span&gt;.</value>
+  </data>
+  <data name="EnvelopeInfo2" xml:space="preserve">
+    <value>Created on {0} by {1}. You can contact the sender via &lt;span class="highlight highlight-envelope-info-2"&gt;&lt;a class="mail-link" href="mailto:{2}?subject={3}&amp;body=Dear%20{4}%20{5},%0A%0A%0A"&gt;{6}&lt;/a&gt;&lt;/span&gt;.</value>
+  </data>
+  <data name="Finalize" xml:space="preserve">
+    <value>Finalize</value>
+  </data>
+  <data name="Hello" xml:space="preserve">
+    <value>Hello</value>
+  </data>
+  <data name="HomePageDescription" xml:space="preserve">
+    <value>The Digital Signature Portal is a platform developed for securely signing and managing your documents. With its user-friendly interface, you can quickly upload your documents, track the signing processes, and easily carry out your digital signature applications. This portal accelerates your workflow with legally valid signatures while enhancing the security of your documents.</value>
+  </data>
+  <data name="LocationWarning" xml:space="preserve">
+    <value>Please review the location information. If it is incorrect, kindly make the necessary corrections.</value>
+  </data>
+  <data name="LockedBodyAccess" xml:space="preserve">
+    <value>We will now send you an access code to your registered e-mail address. This may take a few minutes!</value>
+  </data>
+  <data name="LockedBodyAuthenticator" xml:space="preserve">
+    <value>Please enter the TOTP provided in your Authenticator app.</value>
+  </data>
+  <data name="LockedBodyAuthenticatorNew" xml:space="preserve">
+    <value>We have sent the QR code to your e-mail address. Your QR code is valid until {0}. You can use it for all envelopes received at this email address.</value>
+  </data>
+  <data name="LockedBodySms" xml:space="preserve">
+    <value>We have just sent the access code as an SMS to the phone number you provided.</value>
+  </data>
+  <data name="LockedCodeLabelAccess" xml:space="preserve">
+    <value>Access Code</value>
+  </data>
+  <data name="LockedCodeLabelAuthenticator" xml:space="preserve">
+    <value>TOTP</value>
+  </data>
+  <data name="LockedCodeLabelSms" xml:space="preserve">
+    <value>SMS Code</value>
+  </data>
+  <data name="LockedFooterBodyAccess" xml:space="preserve">
+    <value>Please check your email inbox including the spam folder. You can also ask the sender &lt;a class="mail-link" href="mailto:{0}?subject={1}&amp;body={2}" target="_blank"&gt;{0}&lt;/a&gt; to send you the code by other means.</value>
+  </data>
+  <data name="LockedFooterBodyAuthenticator" xml:space="preserve">
+    <value>The new QR code is sent only once for a given period and is saved in your authenticator app once scanned. It can be used for all envelopes received at the same email address until it expires. If you do not receive the QR code mail or delete it both from the mail and from authenticator, please contact the sender.</value>
+  </data>
+  <data name="LockedFooterBodySms" xml:space="preserve">
+    <value>You can ask the sender to check your phone number. The phone number must be entered with the area code. Otherwise you can request to remove the two-factor protection.</value>
+  </data>
+  <data name="LockedFooterTitleAccess" xml:space="preserve">
+    <value>You have not received an access code?</value>
+  </data>
+  <data name="LockedFooterTitleAuthenticator" xml:space="preserve">
+    <value>You have not received a QR code?</value>
+  </data>
+  <data name="LockedFooterTitleSms" xml:space="preserve">
+    <value>You have not received an SMS?</value>
+  </data>
+  <data name="LockedTitleAccess" xml:space="preserve">
+    <value>Document requires an access code</value>
+  </data>
+  <data name="LockedTitleAuthenticator" xml:space="preserve">
+    <value>2-Factor Authentication</value>
+  </data>
+  <data name="LockedTitleSms" xml:space="preserve">
+    <value>2-Factor Authentication</value>
+  </data>
+  <data name="Privacy" xml:space="preserve">
+    <value>Privacy</value>
+  </data>
+  <data name="ReadOnlyMessage" xml:space="preserve">
+    <value>Forwarded by {0}. Valid until {1}.</value>
+  </data>
+  <data name="Reject" xml:space="preserve">
+    <value>Reject</value>
+  </data>
+  <data name="Rejection" xml:space="preserve">
+    <value>Rejection</value>
+  </data>
+  <data name="RejectionInfo1" xml:space="preserve">
+    <value>This signing process was rejected!</value>
+  </data>
+  <data name="RejectionInfo1_ext" xml:space="preserve">
+    <value>Process canceled!</value>
+  </data>
+  <data name="RejectionInfo2" xml:space="preserve">
+    <value>You can contact {0}, &lt;a href="mailto:{1}?subject={2}&amp;body=Dear%20{0},%0A%0A%0A"&gt;{1}&lt;/a&gt; if required.</value>
+  </data>
+  <data name="RejectionInfo2_ext" xml:space="preserve">
+    <value>The process has been rejected by one of the parties involved. You can contact {0}, &lt;a href="mailto:{1}?subject={2}&amp;body=Dear%20{0},%0A%0A%0A"&gt;{1}&lt;/a&gt; if required.</value>
+  </data>
+  <data name="RejectionReasonQ" xml:space="preserve">
+    <value>Please give a reason:</value>
+  </data>
+  <data name="SigAgree" xml:space="preserve">
+    <value>By clicking on Finalize, I agree that the signature shown and submitted is an electronic representation of my signature in cases where I use it on documents, including legally binding contracts.</value>
+  </data>
+  <data name="SignDoc" xml:space="preserve">
+    <value>Sign document</value>
+  </data>
+  <data name="SigningProcessTitle" xml:space="preserve">
+    <value>Title of the signing process</value>
+  </data>
+  <data name="UnexpectedError" xml:space="preserve">
+    <value>An unexpected error has occurred.</value>
+  </data>
+  <data name="ViewDoc" xml:space="preserve">
+    <value>View document</value>
+  </data>
+  <data name="WelcomeToTheESignPortal" xml:space="preserve">
+    <value>Welcome to the eSign portal</value>
+  </data>
+  <data name="WrongAccessCode" xml:space="preserve">
+    <value>Invalid access code.</value>
+  </data>
+</root>

EnvelopeGenerator.Application/Services/Authenticator.cs

@@ -0,0 +1,71 @@
+using EnvelopeGenerator.Application.Configurations;
+using EnvelopeGenerator.Application.Contracts.Services;
+using Microsoft.Extensions.Options;
+using OtpNet;
+using QRCoder;
+using System.Text;
+
+namespace EnvelopeGenerator.Application.Services
+{
+    public class Authenticator : IAuthenticator
+    {
+        public static Lazy<Authenticator> LazyStatic => new(() => new Authenticator(Options.Create<AuthenticatorParams>(new()), new QRCodeGenerator()));
+
+        public static Authenticator Static => LazyStatic.Value;
+
+        private readonly AuthenticatorParams _params;
+
+        private readonly QRCodeGenerator _qrCodeGenerator;
+
+        public Authenticator(IOptions<AuthenticatorParams> options, QRCodeGenerator qrCodeGenerator)
+        {
+            _params = options.Value;
+            _qrCodeGenerator = qrCodeGenerator;
+        }
+
+        public string GenerateCode(int length)
+        {
+            //TODO: Inject Random as a singleton to support multithreading to improve performance.
+            Random random = new();
+
+            if (length <= 0)
+                throw new ArgumentException("Password length must be greater than 0.");
+
+            var passwordBuilder = new StringBuilder(length);
+
+            for (int i = 0; i < length; i++)
+                passwordBuilder.Append(_params.CharPool[random.Next(_params.CharPool.Length)]);
+
+            return passwordBuilder.ToString();
+        }
+
+        public string GenerateTotpSecretKey(int? length = null)
+            => Base32Encoding.ToString(KeyGeneration.GenerateRandomKey(length ?? _params.DefaultTotpSecretKeyLength));
+
+        public byte[] GenerateTotpQrCode(string userEmail, string secretKey, string? issuer = null, string? totpUrlFormat = null, int? pixelsPerModule = null)
+        {
+            var url = string.Format(totpUrlFormat ?? _params.TotpUrlFormat,
+                Uri.EscapeDataString(userEmail),
+                Uri.EscapeDataString(secretKey),
+                Uri.EscapeDataString(issuer ?? _params.TotpIssuer));
+            using var qrCodeData = _qrCodeGenerator.CreateQrCode(url, QRCodeGenerator.ECCLevel.Q);
+            using var qrCode = new BitmapByteQRCode(qrCodeData);
+            return qrCode.GetGraphic(pixelsPerModule ?? _params.TotpQRPixelsPerModule);
+        }
+
+        public byte[] GenerateTotpQrCode(string userEmail, int? length = null, string? issuer = null, string? totpUrlFormat = null, int? pixelsPerModule = null)
+        {
+            return GenerateTotpQrCode(
+                userEmail: userEmail,
+                secretKey: GenerateTotpSecretKey(length: length),
+                issuer: issuer,
+                totpUrlFormat: totpUrlFormat,
+                pixelsPerModule: pixelsPerModule);
+        }
+
+        public string GenerateTotp(string secretKey, int step = 30) => new Totp(Base32Encoding.ToBytes(secretKey), step).ComputeTotp();
+        
+        public bool VerifyTotp(string totpCode, string secretKey, int step = 30, VerificationWindow? window = null)
+            => new Totp(Base32Encoding.ToBytes(secretKey), step).VerifyTotp(totpCode, out _, window);
+    }
+}

EnvelopeGenerator.Application/Services/ConfigService.cs

@@ -0,0 +1,59 @@
+using AutoMapper;
+using DigitalData.Core.Application;
+using DigitalData.Core.DTO;
+using EnvelopeGenerator.Application.Contracts.Services;
+using EnvelopeGenerator.Application.DTOs;
+using EnvelopeGenerator.Domain.Entities;
+using EnvelopeGenerator.Application.Contracts.Repositories;
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Logging;
+namespace EnvelopeGenerator.Application.Services;
+
+public class ConfigService : ReadService<IConfigRepository, ConfigDto, Config, int>, IConfigService
+{
+		private static readonly Guid DefaultConfigCacheId = Guid.NewGuid();
+
+		private readonly IMemoryCache _cache;
+    private readonly ILogger<ConfigService> _logger;
+		public ConfigService(IConfigRepository repository, IMapper mapper, IMemoryCache memoryCache, ILogger<ConfigService> logger) : base(repository, mapper)
+    {
+			_cache = memoryCache;
+        _logger = logger;
+    }
+
+    public async Task<DataResult<ConfigDto>> ReadFirstAsync()
+    {
+        var config = await _repository.ReadFirstAsync();
+        return config is null 
+            ? Result.Fail<ConfigDto>().Notice(LogLevel.Error, Flag.DataIntegrityIssue, "There is no configuration in DB.")
+            : Result.Success(_mapper.Map<ConfigDto>(config));
+    }
+
+		/// <summary>
+		/// Reads the default configuration asynchronously.
+		/// </summary>
+		/// <remarks>
+		/// The configuration is cached in memory upon the first retrieval. If the configuration is updated, 
+		/// the application needs to be restarted for the changes to take effect as the memory cache will not be updated automatically.
+		/// </remarks>
+		/// <returns>
+		/// A task that represents the asynchronous read operation. The task result contains the default configuration as a <see cref="ConfigDto"/>.
+		/// </returns>
+		/// <exception cref="InvalidOperationException">
+		/// Thrown when the default configuration cannot be found.
+		/// </exception>
+		public async Task<ConfigDto> ReadDefaultAsync()
+    {
+        var config = await _cache.GetOrCreateAsync(DefaultConfigCacheId, _ => ReadFirstAsync().ThenAsync(
+                Success: config => config,
+                Fail: (mssg, ntc) =>
+                {
+                    _logger.LogNotice(ntc);
+                    throw new InvalidOperationException("Default configuration cannot find.");
+                }));
+
+        return config!;
+    }
+
+    public async Task<string> ReadDefaultSignatureHost() => (await ReadDefaultAsync()).SignatureHost;
+}

EnvelopeGenerator.Application/Services/DocumentReceiverElementService.cs

@@ -0,0 +1,16 @@
+using AutoMapper;
+using DigitalData.Core.Application;
+using EnvelopeGenerator.Application.Contracts.Services;
+using EnvelopeGenerator.Application.DTOs;
+using EnvelopeGenerator.Domain.Entities;
+using EnvelopeGenerator.Application.Contracts.Repositories;
+
+namespace EnvelopeGenerator.Application.Services;
+
+public class DocumentReceiverElementService : BasicCRUDService<IDocumentReceiverElementRepository, DocumentReceiverElementDto, DocumentReceiverElement, int>, IDocumentReceiverElementService
+{
+    public DocumentReceiverElementService(IDocumentReceiverElementRepository repository, IMapper mapper)
+        : base(repository, mapper)
+    {
+    }
+}

EnvelopeGenerator.Application/Services/DocumentStatusService.cs

@@ -0,0 +1,16 @@
+using AutoMapper;
+using DigitalData.Core.Application;
+using EnvelopeGenerator.Application.Contracts.Services;
+using EnvelopeGenerator.Application.DTOs;
+using EnvelopeGenerator.Domain.Entities;
+using EnvelopeGenerator.Application.Contracts.Repositories;
+
+namespace EnvelopeGenerator.Application.Services;
+
+public class DocumentStatusService : BasicCRUDService<IDocumentStatusRepository, DocumentStatusDto, DocumentStatus, int>, IDocumentStatusService
+{
+    public DocumentStatusService(IDocumentStatusRepository repository, IMapper mapper)
+        : base(repository, mapper)
+    {
+    }
+}

EnvelopeGenerator.Application/Services/EmailTemplateService.cs

@@ -0,0 +1,29 @@
+using AutoMapper;
+using DigitalData.Core.Application;
+using EnvelopeGenerator.Application.DTOs;
+using EnvelopeGenerator.Domain.Entities;
+using EnvelopeGenerator.Application.Contracts.Repositories;
+using static EnvelopeGenerator.Common.Constants;
+using DigitalData.Core.DTO;
+using Microsoft.Extensions.Logging;
+using EnvelopeGenerator.Application.Contracts.Services;
+
+namespace EnvelopeGenerator.Application.Services;
+
+public class EmailTemplateService : BasicCRUDService<IEmailTemplateRepository, EmailTemplateDto, EmailTemplate, int>, IEmailTemplateService
+{
+    public EmailTemplateService(IEmailTemplateRepository repository, IMapper mapper)
+        : base(repository, mapper)
+    {
+    }
+
+    public async Task<DataResult<EmailTemplateDto>> ReadByNameAsync(EmailTemplateType type)
+    {
+        var temp = await _repository.ReadByNameAsync(type);
+        return temp is null 
+            ? Result.Fail<EmailTemplateDto>()
+                .Message(Key.InnerServiceError)
+                .Notice(LogLevel.Error, Flag.DataIntegrityIssue, $"EmailTemplateType '{type}' is not found in DB. Please, define required e-mail template.")
+            : Result.Success(_mapper.Map<EmailTemplateDto>(temp));
+    }
+}

EnvelopeGenerator.Application/Services/EnvelopeCertificateService.cs

@@ -0,0 +1,17 @@
+using AutoMapper;
+using DigitalData.Core.Application;
+using Microsoft.Extensions.Localization;
+using EnvelopeGenerator.Application.DTOs;
+using EnvelopeGenerator.Domain.Entities;
+using EnvelopeGenerator.Application.Contracts.Repositories;
+using EnvelopeGenerator.Application.Contracts.Services;
+
+namespace EnvelopeGenerator.Application.Services;
+
+public class EnvelopeCertificateService : BasicCRUDService<IEnvelopeCertificateRepository, EnvelopeCertificateDto, EnvelopeCertificate, int>, IEnvelopeCertificateService
+{
+    public EnvelopeCertificateService(IEnvelopeCertificateRepository repository, IMapper mapper)
+        : base(repository, mapper)
+    {
+    }
+}

EnvelopeGenerator.Application/Services/EnvelopeDocumentService.cs

@@ -0,0 +1,15 @@
+using AutoMapper;
+using DigitalData.Core.Application;
+using EnvelopeGenerator.Application.Contracts.Services;
+using EnvelopeGenerator.Application.DTOs;
+using EnvelopeGenerator.Domain.Entities;
+using EnvelopeGenerator.Application.Contracts.Repositories;
+
+namespace EnvelopeGenerator.Application.Services;
+
+public class EnvelopeDocumentService : BasicCRUDService<IEnvelopeDocumentRepository, EnvelopeDocumentDto, EnvelopeDocument, int>, IEnvelopeDocumentService
+{
+    public EnvelopeDocumentService(IEnvelopeDocumentRepository repository, IMapper mapper) : base(repository, mapper)
+    {
+    }
+}

EnvelopeGenerator.Application/Services/EnvelopeHistoryService.cs

@@ -0,0 +1,84 @@
+using AutoMapper;
+using DigitalData.Core.Application;
+using EnvelopeGenerator.Domain.Entities;
+using EnvelopeGenerator.Application.Contracts.Repositories;
+using static EnvelopeGenerator.Common.Constants;
+using DigitalData.Core.DTO;
+using EnvelopeGenerator.Application.DTOs.EnvelopeHistory;
+using EnvelopeGenerator.Application.DTOs.Receiver;
+using EnvelopeGenerator.Application.Contracts.Services;
+
+namespace EnvelopeGenerator.Application.Services;
+
+public class EnvelopeHistoryService : CRUDService<IEnvelopeHistoryRepository, EnvelopeHistoryCreateDto, EnvelopeHistoryDto, EnvelopeHistory, long>, IEnvelopeHistoryService
+{
+    public EnvelopeHistoryService(IEnvelopeHistoryRepository repository, IMapper mapper)
+        : base(repository, mapper)
+    {
+    }
+
+    public async Task<int> CountAsync(int? envelopeId = null, string? userReference = null, int? status = null) => await _repository.CountAsync(envelopeId: envelopeId, userReference: userReference, status: status);
+
+    public async Task<bool> HasStatus(EnvelopeStatus status, int envelopeId, string userReference) => await _repository.CountAsync(
+        envelopeId: envelopeId,
+        userReference: userReference,
+        status: (int) status) > 0;
+
+    public async Task<bool> AccessCodeAlreadyRequested(int envelopeId, string userReference) => await _repository.CountAsync(
+        envelopeId: envelopeId,
+        userReference:userReference,
+        status: (int) EnvelopeStatus.AccessCodeRequested) > 0;
+
+    public async Task<bool> IsSigned(int envelopeId, string userReference) => await _repository.CountAsync(
+        envelopeId: envelopeId,
+        userReference: userReference,
+        status: (int) EnvelopeStatus.DocumentSigned) > 0;
+
+    /// <summary>
+    /// Checks if the specified envelope has been rejected.
+    /// <para><b>Note:</b> <i>If any document within the envelope is rejected, the entire envelope will be considered rejected.</i></para>
+    /// </summary>
+    /// <param name="envelopeId">The ID of the envelope to check.</param>
+    /// <param name="userReference">Optional user reference associated with the envelope.</param>
+    /// <returns>A task that represents the asynchronous operation. The task result contains a boolean value indicating whether the envelope is rejected.</returns>
+    public async Task<bool> IsRejected(int envelopeId, string? userReference = null)
+    {
+        return await _repository.CountAsync(
+            envelopeId: envelopeId,
+            userReference: userReference,
+            status: (int)EnvelopeStatus.DocumentRejected) > 0;
+    }
+
+    public async Task<IEnumerable<EnvelopeHistoryDto>> ReadAsync(int? envelopeId = null, string? userReference = null, ReferenceType? referenceType = null, int? status = null, bool withSender = false, bool withReceiver = false)
+    {
+        var histDTOs = _mapper.Map<IEnumerable<EnvelopeHistoryDto>>(
+                    await _repository.ReadAsync(
+                                envelopeId: envelopeId,
+                                userReference: userReference,
+                                status: status,
+                                withSender: withSender,
+                                withReceiver: withReceiver));
+        return referenceType is null ? histDTOs : histDTOs.Where(h => h.ReferenceType == referenceType);
+    }
+
+    public async Task<IEnumerable<EnvelopeHistoryDto>> ReadRejectedAsync(int envelopeId, string? userReference = null) =>
+        await ReadAsync(envelopeId: envelopeId, userReference: userReference, status: (int)EnvelopeStatus.DocumentRejected, withReceiver:true);
+
+		//TODO: use IQueryable in repository to incerease the performance
+		public async Task<IEnumerable<ReceiverReadDto>> ReadRejectingReceivers(int envelopeId)
+		{
+			var envelopes = await ReadRejectedAsync(envelopeId);
+        return envelopes is null
+            ? Enumerable.Empty<ReceiverReadDto>()
+            : envelopes
+                .Where(eh => eh?.Receiver != null)
+                .Select(eh => eh.Receiver!);
+		}
+
+		public async Task<DataResult<long>> RecordAsync(int envelopeId, string userReference, EnvelopeStatus status, string? comment = null) => 
+        await CreateAsync(new (EnvelopeId: envelopeId, UserReference: userReference, Status: (int)status, ActionDate: DateTime.Now, Comment: comment))
+            .ThenAsync(
+                Success: id => Result.Success(id),
+                Fail: (mssg, ntc) => Result.Fail<long>().Message(mssg).Notice(ntc)
+            );
+}

EnvelopeGenerator.Application/Services/EnvelopeMailService.cs

@@ -0,0 +1,175 @@
+using AutoMapper;
+using DigitalData.Core.DTO;
+using DigitalData.EmailProfilerDispatcher.Abstraction.Contracts;
+using DigitalData.EmailProfilerDispatcher.Abstraction.DTOs.EmailOut;
+using DigitalData.EmailProfilerDispatcher.Abstraction.Services;
+using EnvelopeGenerator.Application.DTOs.EnvelopeReceiver;
+using EnvelopeGenerator.Common;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using static EnvelopeGenerator.Common.Constants;
+using EnvelopeGenerator.Extensions;
+using EnvelopeGenerator.Application.DTOs.EnvelopeReceiverReadOnly;
+using EnvelopeGenerator.Application.Configurations;
+using EnvelopeGenerator.Application.Extensions;
+using Newtonsoft.Json;
+using EnvelopeGenerator.Application.Contracts.Services;
+
+namespace EnvelopeGenerator.Application.Services
+{
+    public class EnvelopeMailService : EmailOutService, IEnvelopeMailService
+    {
+		private readonly IEmailTemplateService _tempService;
+		private readonly IEnvelopeReceiverService _envRcvService;
+		private readonly DispatcherParams _dConfig;
+		private readonly IConfigService _configService;
+		private readonly Dictionary<string, string> _placeholders;
+		private readonly IAuthenticator _authenticator;
+
+        public EnvelopeMailService(IEmailOutRepository repository, IMapper mapper, IEmailTemplateService tempService, IEnvelopeReceiverService envelopeReceiverService, IOptions<DispatcherParams> dispatcherConfigOptions, IConfigService configService, IOptions<MailParams> mailConfig, IAuthenticator authenticator) : base(repository, mapper)
+        {
+            _tempService = tempService;
+			_envRcvService = envelopeReceiverService;
+			_dConfig = dispatcherConfigOptions.Value;
+			_configService = configService;
+			_placeholders = mailConfig.Value.Placeholders;
+			_authenticator = authenticator;
+        }
+
+		private async Task<Dictionary<string, string>> CreatePlaceholders(string? accessCode = null, EnvelopeReceiverDto? envelopeReceiverDto = null)
+		{
+			if (accessCode is not null)
+                _placeholders["[DOCUMENT_ACCESS_CODE]"] = accessCode;
+
+			if(envelopeReceiverDto?.Envelope is not null && envelopeReceiverDto.Receiver is not null)
+			{
+				var erId = (envelopeReceiverDto.Envelope.Uuid, envelopeReceiverDto.Receiver.Signature).EncodeEnvelopeReceiverId();
+				var sigHost = await _configService.ReadDefaultSignatureHost();
+				var linkToDoc = $"{sigHost}/EnvelopeKey/{erId}";
+				_placeholders["[LINK_TO_DOCUMENT]"] = linkToDoc;
+				_placeholders["[LINK_TO_DOCUMENT_TEXT]"] = linkToDoc[..Math.Min(40, linkToDoc.Length)] + "..";
+			}
+
+			return _placeholders;
+		}
+
+        private async Task<Dictionary<string, string>> CreatePlaceholders(EnvelopeReceiverReadOnlyDto? readOnlyDto = null)
+        {
+            if (readOnlyDto?.Envelope is not null && readOnlyDto.Receiver is not null)
+            {
+                _placeholders["[NAME_RECEIVER]"] = await _envRcvService.ReadLastUsedReceiverNameByMail(readOnlyDto.AddedWho).ThenAsync(res => res, (msg, ntc) => string.Empty) ?? string.Empty;
+                var erReadOnlyId = (readOnlyDto.Id).EncodeEnvelopeReceiverId();
+                var sigHost = await _configService.ReadDefaultSignatureHost();
+                var linkToDoc = $"{sigHost}/EnvelopeKey/{erReadOnlyId}";
+                _placeholders["[LINK_TO_DOCUMENT]"] = linkToDoc;
+                _placeholders["[LINK_TO_DOCUMENT_TEXT]"] = linkToDoc[..Math.Min(40, linkToDoc.Length)] + "..";
+            }
+
+            return _placeholders;
+        }
+		
+        public async Task<DataResult<int>> SendAsync(EnvelopeReceiverDto dto, EmailTemplateType tempType, Dictionary<string, object>? optionalPlaceholders = null)
+        {
+			var tempSerResult = await _tempService.ReadByNameAsync(tempType);
+			if (tempSerResult.IsFailed)
+				return tempSerResult.ToFail<int>().Notice(LogLevel.Error, Flag.DataIntegrityIssue, $"The email cannot send because '{tempType}' template cannot found.");
+			var temp = tempSerResult.Data;
+
+			var mail = new EmailOutCreateDto()
+			{
+				EmailAddress = dto.Receiver!.EmailAddress,
+				EmailSubj = temp.Subject,
+				EmailBody = temp.Body,
+				//email_type = envelope_status,
+				//message = envelope_message,
+				ReferenceId = dto.EnvelopeId,               //REFERENCE_ID = ENVELOPE_ID
+				ReferenceString = dto!.Envelope!.Uuid,		//REFERENCE_STRING = ENVELOPE_UUID
+				//receiver_name = receiver.name,
+				//receiver_access_code = receiver.access_code,
+				//sender_adress = envelope.user.email,
+				//sender_name = envelope.user.full_name,
+				//envelope_title = envelope.title,
+				ReminderTypeId = _dConfig.ReminderTypeId,
+				SendingProfile = _dConfig.SendingProfile,
+				EntityId = null,
+				WfId = (int) EnvelopeStatus.MessageAccessCodeSent,
+				WfReference = null,
+				AddedWho = _dConfig.AddedWho,
+				EmailAttmt1 = _dConfig.EmailAttmt1
+			};
+
+			//get acccess code
+			var acResult = await _envRcvService.ReadAccessCodeByIdAsync(envelopeId: dto.EnvelopeId, receiverId: dto.ReceiverId);
+			if (acResult.IsFailed)
+				return acResult.ToFail<int>().Notice(LogLevel.Error, "Therefore, access code cannot be sent");
+			var accessCode = acResult.Data;
+			
+			var placeholders = await CreatePlaceholders(accessCode: accessCode, envelopeReceiverDto: dto);
+
+			// Add optional place holders.
+			if (optionalPlaceholders is not null)
+				foreach (var oph in optionalPlaceholders)
+					placeholders[oph.Key] = oph.Value.ToString() ?? "NULL";
+
+			//TODO: remove the requirement to add the models using reflections
+			return await CreateWithTemplateAsync(createDto: mail,placeholders: placeholders,
+				dto, dto.Envelope.User!, dto.Envelope);
+		}
+
+		public async Task<DataResult<int>> SendAsync(EnvelopeReceiverReadOnlyDto dto, Dictionary<string, object>? optionalPlaceholders = null)
+		{
+            var tempSerResult = await _tempService.ReadByNameAsync(EmailTemplateType.DocumentShared);
+            if (tempSerResult.IsFailed)
+                return tempSerResult.ToFail<int>().Notice(LogLevel.Error, Flag.DataIntegrityIssue, $"The email cannot send because '{Constants.EmailTemplateType.DocumentShared}' template cannot found.");
+            var temp = tempSerResult.Data;
+
+            var mail = new EmailOutCreateDto()
+            {
+                EmailAddress = dto.ReceiverMail,
+                EmailSubj = temp.Subject,
+                EmailBody = temp.Body,
+				//TODO: remove int casting when all 
+                ReferenceId = (int) dto.EnvelopeId,			//REFERENCE_ID = ENVELOPE_ID
+                ReferenceString = dto.Envelope!.Uuid,		//REFERENCE_STRING = ENVELOPE_UUID
+                                                            //receiver_name = receiver.name,
+                                                            //receiver_access_code = receiver.access_code,
+                                                            //sender_adress = envelope.user.email,
+                                                            //sender_name = envelope.user.full_name,
+                                                            //envelope_title = envelope.title,
+                ReminderTypeId = _dConfig.ReminderTypeId,
+                SendingProfile = _dConfig.SendingProfile,
+                EntityId = null,
+                WfId = (int)EnvelopeStatus.EnvelopeShared,
+                WfReference = null,
+                AddedWho = _dConfig.AddedWho,
+                EmailAttmt1 = _dConfig.EmailAttmt1
+            };
+
+            var placeholders = await CreatePlaceholders(readOnlyDto: dto);
+
+            // Add optional place holders.
+            if (optionalPlaceholders is not null)
+                foreach (var oph in optionalPlaceholders)
+                placeholders[oph.Key] = oph.Value.ToString() ?? "NULL";
+
+            return await CreateWithTemplateAsync(createDto: mail, placeholders: placeholders, dto.Envelope);
+        }
+
+        public async Task<DataResult<int>> SendAccessCodeAsync(EnvelopeReceiverDto dto) => await SendAsync(dto: dto, tempType: EmailTemplateType.DocumentAccessCodeReceived);
+
+        public Task<DataResult<int>> SendTFAQrCodeAsync(EnvelopeReceiverDto dto)
+        {
+            // Check if receiver or secret key is null
+            if (dto.Receiver is null)
+                throw new ArgumentNullException(nameof(dto), $"TFA Qr Code cannot sent. Receiver information is missing. Envelope receiver dto is {JsonConvert.SerializeObject(dto)}");
+            if (dto.Receiver.TotpSecretkey is null)
+                throw new ArgumentNullException(nameof(dto), $"TFA Qr Code cannot sent. Receiver.TotpSecretKey is null. Envelope receiver dto is {JsonConvert.SerializeObject(dto)}");
+
+            var totp_qr_64 = _authenticator.GenerateTotpQrCode(userEmail: dto.Receiver.EmailAddress, secretKey: dto.Receiver.TotpSecretkey).ToBase64String();
+            return SendAsync(dto, EmailTemplateType.TotpSecret, new()
+			{
+				{"[TFA_QR_CODE]", totp_qr_64 },
+			});
+        }
+    }
+}