refactor(CodeGenerator): umbenannt in Authenticator

- Entfernte redundante `AddEnvelopeGenerator`-Überladung.
- Einführung der Erweiterungsmethode `ConfigureByTypeName<TOptions>` für eine sauberere Konfiguration.
- Ersetzte explizite Konfigurationsaufrufe durch `ConfigureByTypeName<TOptions>`.
- Verbesserte Wartbarkeit durch Reduzierung von redundantem Code.
- Markierte `ConfigureByTypeName<TOptions>` zur zukünftigen Verlagerung nach `DigitalData.Core`.

EnvelopeGenerator.Application/Configurations/AuthenticatorParams.cs

@@ -1,6 +1,6 @@
 namespace EnvelopeGenerator.Application.Configurations
 {
-    public class CodeGeneratorParams
+    public class AuthenticatorParams
     {
         public string CharPool { get; init; } = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz01234567890123456789012345678901234567890123456789";
 

EnvelopeGenerator.Application/Configurations/DispatcherConfig.cs

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

EnvelopeGenerator.Application/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/EnvelopeReceiverCacheParams.cs

@@ -1,17 +0,0 @@
-namespace EnvelopeGenerator.Application.Configurations
-{
-    public class EnvelopeReceiverCacheParams
-    {
-        /// <summary>
-        /// Gets the cache key format for SMS codes.
-        /// The placeholder {0} represents the envelopeReceiverId.
-        /// </summary>
-        public string CodeCacheKeyFormat { get; init; } = "sms-code-{0}";
-
-        /// <summary>
-        /// Gets the cache expiration key format for SMS codes.
-        /// The placeholder {0} represents the envelopeReceiverId.
-        /// </summary>
-        public string CodeExpirationCacheKeyFormat { get; init; } = "sms-code-expiration-{0}";
-    }
-}

EnvelopeGenerator.Application/Configurations/GtxMessaging/SmsParams.cs

@@ -1,30 +0,0 @@
-using DigitalData.Core.Abstractions.Client;
-using Microsoft.Extensions.Caching.Distributed;
-using OtpNet;
-
-namespace EnvelopeGenerator.Application.Configurations.GtxMessaging
-{
-    /// <summary>
-    /// https://www.gtx-messaging.com/en/api-docs/sms-rest-api/
-    /// </summary>
-    public class SmsParams : 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";
-
-        public int CodeLength { get; init; } = 5;
-
-        public int SmsTotpStep { get; init; } = 300;
-
-        public string DefaultTotpMessageFormat { get; init; } = "{0}";
-    }
-}

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/MailConfig.cs

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

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/IAuthenticator.cs

@@ -2,7 +2,7 @@
 
 namespace EnvelopeGenerator.Application.Contracts
 {
-    public interface ICodeGenerator
+    public interface IAuthenticator
     {
         string GenerateCode(int length);
 
@@ -15,7 +15,5 @@ namespace EnvelopeGenerator.Application.Contracts
         string GenerateTotp(string secretKey, int step = 30);
 
         bool VerifyTotp(string totpCode, string secretKey, int step = 30, VerificationWindow? window = null);
-
-        bool GetTotpExpirationTime(int step = 30);
     }
 }

EnvelopeGenerator.Application/Contracts/IEnvelopeSmsHandler.cs

@@ -0,0 +1,17 @@
+using EnvelopeGenerator.Application.DTOs.EnvelopeReceiver;
+using EnvelopeGenerator.Application.DTOs.Messaging;
+
+namespace EnvelopeGenerator.Application.Contracts;
+
+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/IJWTService.cs

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

EnvelopeGenerator.Application/Contracts/ISmsSender.cs

@@ -2,11 +2,10 @@
 
 namespace EnvelopeGenerator.Application.Contracts;
 
-public interface IMessagingService
+//TODO: move to DigitalData.Core
+public interface ISmsSender
 {
     string ServiceProvider { get; }
 
     Task<SmsResponse> SendSmsAsync(string recipient, string message);
-
-    Task<SmsResponse> SendSmsCodeAsync(string recipient, string secretKey, string messageFormat = "{0}");
 }

EnvelopeGenerator.Application/DTOs/Messaging/SmsResponse.cs

@@ -4,6 +4,8 @@
     {
         public required bool Ok { get; init; }
 
+        public bool Failed => !Ok;
+
         public dynamic? Errors { get; init; }
     }
 }

EnvelopeGenerator.Application/Extensions/DIExtensions.cs

@@ -9,14 +9,13 @@ using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
 using DigitalData.Core.Client;
-using EnvelopeGenerator.Application.Configurations.GtxMessaging;
 using QRCoder;
 
 namespace EnvelopeGenerator.Application.Extensions
 {
     public static class DIExtensions
     {
-        public static IServiceCollection AddEnvelopeGenerator(this IServiceCollection services, IConfigurationSection dispatcherConfigSection, IConfigurationSection mailConfigSection, IConfigurationSection smsConfigSection, IConfigurationSection codeGeneratorConfigSection, IConfigurationSection envelopeReceiverCacheParamsSection)
+        public static IServiceCollection AddEnvelopeGenerator(this IServiceCollection services, IConfiguration config)
         {
             //Inject CRUD Service and repositoriesad
             services.TryAddScoped<IConfigRepository, ConfigRepository>();
@@ -54,25 +53,22 @@ namespace EnvelopeGenerator.Application.Extensions
             services.AddAutoMapper(typeof(BasicDtoMappingProfile).Assembly);
             services.AddAutoMapper(typeof(UserMappingProfile).Assembly);
 
-            services.Configure<DispatcherConfig>(dispatcherConfigSection);
-            services.Configure<MailConfig>(mailConfigSection);
-            services.Configure<CodeGeneratorParams>(codeGeneratorConfigSection);
-            services.Configure<EnvelopeReceiverCacheParams>(envelopeReceiverCacheParamsSection);
+            services.ConfigureByTypeName<DispatcherParams>(config);
+            services.ConfigureByTypeName<MailParams>(config);
+            services.ConfigureByTypeName<AuthenticatorParams>(config);
+            services.ConfigureByTypeName<TotpSmsParams>(config);
 
-            services.AddHttpClientService<SmsParams>(smsConfigSection);
-            services.TryAddSingleton<IMessagingService, GtxMessagingService>();
-            services.TryAddSingleton<ICodeGenerator, CodeGenerator>();
-            services.TryAddSingleton<IEnvelopeReceiverCache, EnvelopeReceiverCache>();
+            services.AddHttpClientService<GtxMessagingParams>(config.GetSection(nameof(GtxMessagingParams)));
+            services.TryAddSingleton<ISmsSender, GTXSmsSender>();
+            services.TryAddSingleton<IEnvelopeSmsHandler, EnvelopeSmsHandler>();
+            services.TryAddSingleton<IAuthenticator, Authenticator>();
             services.TryAddSingleton<QRCodeGenerator>();
 
             return services;
         }
 
-        public static IServiceCollection AddEnvelopeGenerator(this IServiceCollection services, IConfiguration config) => services.AddEnvelopeGenerator(
-            dispatcherConfigSection: config.GetSection("DispatcherConfig"),
-            mailConfigSection: config.GetSection("MailConfig"),
-            smsConfigSection: config.GetSection("SmsConfig"),
-            codeGeneratorConfigSection: config.GetSection("CodeGeneratorParams"),
-            envelopeReceiverCacheParamsSection: config.GetSection("EnvelopeReceiverCacheParams"));
+        //TODO: move to DigitalData.Core
+        private static IServiceCollection ConfigureByTypeName<TOptions>(this IServiceCollection services, IConfiguration configuration) where TOptions : class
+            => services.Configure<TOptions>(configuration.GetSection(nameof(TOptions)));
     }
 }

EnvelopeGenerator.Application/Services/Authenticator.cs

@@ -7,17 +7,17 @@ using System.Text;
 
 namespace EnvelopeGenerator.Application.Services
 {
-    public class CodeGenerator : ICodeGenerator
+    public class Authenticator : IAuthenticator
     {
-        public static Lazy<CodeGenerator> LazyStatic => new(() => new CodeGenerator(Options.Create<CodeGeneratorParams>(new()), new QRCodeGenerator()));
+        public static Lazy<Authenticator> LazyStatic => new(() => new Authenticator(Options.Create<AuthenticatorParams>(new()), new QRCodeGenerator()));
 
-        public static CodeGenerator Static => LazyStatic.Value;
+        public static Authenticator Static => LazyStatic.Value;
 
-        private readonly CodeGeneratorParams _params;
+        private readonly AuthenticatorParams _params;
 
         private readonly QRCodeGenerator _qrCodeGenerator;
 
-        public CodeGenerator(IOptions<CodeGeneratorParams> options, QRCodeGenerator qrCodeGenerator)
+        public Authenticator(IOptions<AuthenticatorParams> options, QRCodeGenerator qrCodeGenerator)
         {
             _params = options.Value;
             _qrCodeGenerator = qrCodeGenerator;
@@ -67,10 +67,5 @@ namespace EnvelopeGenerator.Application.Services
         
         public bool VerifyTotp(string totpCode, string secretKey, int step = 30, VerificationWindow? window = null)
             => new Totp(Base32Encoding.ToBytes(secretKey), step).VerifyTotp(totpCode, out _, window);
-
-        public bool GetTotpExpirationTime(int step = 30)
-        {
-            throw new NotImplementedException();
-        }
     }
 }

EnvelopeGenerator.Application/Services/EnvelopeMailService.cs

@@ -21,19 +21,19 @@ namespace EnvelopeGenerator.Application.Services
     {
 		private readonly IEmailTemplateService _tempService;
 		private readonly IEnvelopeReceiverService _envRcvService;
-		private readonly DispatcherConfig _dConfig;
+		private readonly DispatcherParams _dConfig;
 		private readonly IConfigService _configService;
 		private readonly Dictionary<string, string> _placeholders;
-		private readonly ICodeGenerator _codeGenerator;
+		private readonly IAuthenticator _authenticator;
 
-        public EnvelopeMailService(IEmailOutRepository repository, IMapper mapper, IEmailTemplateService tempService, IEnvelopeReceiverService envelopeReceiverService, IOptions<DispatcherConfig> dispatcherConfigOptions, IConfigService configService, IOptions<MailConfig> mailConfig, ICodeGenerator codeGenerator) : base(repository, mapper)
+        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;
-			_codeGenerator = codeGenerator;
+			_authenticator = authenticator;
         }
 
 		private async Task<Dictionary<string, string>> CreatePlaceholders(string? accessCode = null, EnvelopeReceiverDto? envelopeReceiverDto = null)
@@ -167,7 +167,7 @@ namespace EnvelopeGenerator.Application.Services
             if (dto.Receiver.TotpExpiration is null)
                 throw new ArgumentNullException(nameof(dto), $"TFA Qr Code cannot sent. Receiver.TotpExpiration is null. Envelope receiver dto is {JsonConvert.SerializeObject(dto)}");
 
-            var totp_qr_64 = _codeGenerator.GenerateTotpQrCode(userEmail: dto.Receiver.EmailAddress, secretKey: dto.Receiver.TotpSecretkey).ToBase64String();
+            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 },

EnvelopeGenerator.Application/Services/EnvelopeReceiverService.cs

@@ -17,13 +17,13 @@ namespace EnvelopeGenerator.Application.Services
     {
         private readonly IStringLocalizer<Resource> _localizer;
 
-        private readonly IMessagingService _messagingService;
+        private readonly ISmsSender _smsSender;
 
-        public EnvelopeReceiverService(IEnvelopeReceiverRepository repository, IStringLocalizer<Resource> localizer, IMapper mapper, IMessagingService messagingService)
+        public EnvelopeReceiverService(IEnvelopeReceiverRepository repository, IStringLocalizer<Resource> localizer, IMapper mapper, ISmsSender smsSender)
             : base(repository, mapper)
         {
             _localizer = localizer;
-            _messagingService = messagingService;
+            _smsSender = smsSender;
         }
 
         public async Task<DataResult<IEnumerable<EnvelopeReceiverDto>>> ReadBySignatureAsync(string signature, bool withEnvelope = false, bool withReceiver = true, bool readOnly = true)
@@ -171,7 +171,7 @@ namespace EnvelopeGenerator.Application.Services
                     .Message(Key.PhoneNumberNonexists)
                     .Notice(LogLevel.Error, Flag.NotFound, $"An attempt was made to send sms to the user whose phone number is null. Envelope recipient ID is {envelopeReceiverId}, UUID is {uuid} and signature is {signature}.");
 
-            var res = await _messagingService.SendSmsAsync(recipient: env_rcv.PhoneNumber, message: message);
+            var res = await _smsSender.SendSmsAsync(recipient: env_rcv.PhoneNumber, message: message);
 
             return Result.Success(res);
         }

EnvelopeGenerator.Application/Services/EnvelopeSmsHandler.cs

@@ -0,0 +1,53 @@
+using EnvelopeGenerator.Application.Configurations;
+using EnvelopeGenerator.Application.Contracts;
+using EnvelopeGenerator.Application.DTOs.EnvelopeReceiver;
+using EnvelopeGenerator.Application.DTOs.Messaging;
+using EnvelopeGenerator.Application.Extensions;
+using Microsoft.Extensions.Caching.Distributed;
+using Microsoft.Extensions.Options;
+
+namespace EnvelopeGenerator.Application.Services;
+
+public class EnvelopeSmsHandler : IEnvelopeSmsHandler
+{
+    private readonly ISmsSender _sender;
+
+    private readonly TotpSmsParams _totpSmsParams;
+
+    private readonly IDistributedCache _dCache;
+
+    private readonly IAuthenticator _authenticator;
+
+    public EnvelopeSmsHandler(ISmsSender sender, IOptions<TotpSmsParams> totpSmsParamsOptions, IDistributedCache distributedCache, IAuthenticator authenticator)
+    {
+        _sender = sender;
+        _totpSmsParams = totpSmsParamsOptions.Value;
+        _dCache = distributedCache;
+        _authenticator = authenticator;
+    }
+
+    /// <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>
+    public async Task<(SmsResponse? SmsResponse, DateTime Expiration)> SendTotpAsync(EnvelopeReceiverSecretDto er_secret, CancellationToken cToken = default)
+    {
+        var key = string.Format(_totpSmsParams.Expiration.CacheKeyFormat, er_secret.EnvelopeId, er_secret.ReceiverId);
+        var expiration = await _dCache.GetDateTimeAsync(key, cToken);
+
+        if(expiration is DateTime expirationDateTime && expirationDateTime < DateTime.Now)
+            return (null, expirationDateTime);
+        else
+        {
+            var new_expiration = DateTime.Now.AddSeconds(_totpSmsParams.TotpStep);
+            var totp = _authenticator.GenerateTotp(er_secret.Receiver!.TotpSecretkey!, _totpSmsParams.TotpStep);
+            var msg = string.Format(_totpSmsParams.Format, totp, new_expiration.ToString(_totpSmsParams.Expiration.Format, _totpSmsParams.Expiration.CultureInfo));
+            return (await _sender.SendSmsAsync(er_secret.PhoneNumber!, msg), new_expiration);
+        }
+    }
+
+    public bool VerifyTotp(string totpCode, string secretKey) => _authenticator
+        .VerifyTotp(totpCode, secretKey, _totpSmsParams.TotpStep, _totpSmsParams.TotpVerificationWindow);
+}

EnvelopeGenerator.Application/Services/GTXSmsSender.cs

@@ -1,32 +1,30 @@
 using AutoMapper;
 using DigitalData.Core.Abstractions.Client;
 using DigitalData.Core.Client;
-using EnvelopeGenerator.Application.Configurations.GtxMessaging;
+using EnvelopeGenerator.Application.Configurations;
 using EnvelopeGenerator.Application.Contracts;
 using EnvelopeGenerator.Application.DTOs.Messaging;
 using Microsoft.Extensions.Options;
 
 namespace EnvelopeGenerator.Application.Services;
 
-public class GtxMessagingService : IMessagingService
+//TODO: move to DigitalData.Core
+public class GTXSmsSender : ISmsSender
 {
-    private readonly IHttpClientService<SmsParams> _smsClient;
+    private readonly IHttpClientService<GtxMessagingParams> _smsClient;
 
-    private readonly SmsParams _smsParams;
+    private readonly GtxMessagingParams _smsParams;
 
     private readonly IMapper _mapper;
 
-    private readonly ICodeGenerator _codeGen;
-
     public string ServiceProvider { get; }
 
-    public GtxMessagingService(IHttpClientService<SmsParams> smsClient, IOptions<SmsParams> smsParamsOptions, IMapper mapper, ICodeGenerator codeGenerator)
+    public GTXSmsSender(IHttpClientService<GtxMessagingParams> smsClient, IOptions<GtxMessagingParams> smsParamsOptions, IMapper mapper)
     {
         _smsClient = smsClient;
         _smsParams = smsParamsOptions.Value;
         _mapper = mapper;
         ServiceProvider = GetType().Name.Replace("Service", string.Empty);
-        _codeGen = codeGenerator;
     }
 
     public async Task<SmsResponse> SendSmsAsync(string recipient, string message)
@@ -39,11 +37,4 @@ public class GtxMessagingService : IMessagingService
         .ThenAsync(res => res.Json<GtxMessagingResponse>())
         .ThenAsync(_mapper.Map<SmsResponse>);
     }
-
-    public async Task<SmsResponse> SendSmsCodeAsync(string recipient, string secretKey, string? messageFormat = null)
-    {
-        var code = _codeGen.GenerateTotp(secretKey, _smsParams.SmsTotpStep);
-        var message = string.Format(messageFormat ?? _smsParams.DefaultTotpMessageFormat, code);
-        return await SendSmsAsync(recipient: recipient, message: message);
-    }
 }

EnvelopeGenerator.Web/Controllers/HomeController.cs

@@ -35,13 +35,11 @@ namespace EnvelopeGenerator.Web.Controllers
         private readonly Cultures _cultures;
         private readonly IEnvelopeMailService _mailService;
         private readonly IEnvelopeReceiverReadOnlyService _readOnlyService;
-        private readonly IMessagingService _msgService;
-        private readonly ICodeGenerator _codeGenerator;
+        private readonly IAuthenticator _authenticator;
         private readonly IReceiverService _rcvService;
-        private static readonly int SmsTotpStep = 60 * 3;
-        private static readonly string SmsFormat = "{0}";
+        private readonly IEnvelopeSmsHandler _envSmsHandler;
 
-        public HomeController(EnvelopeOldService envelopeOldService, ILogger<HomeController> logger, IEnvelopeReceiverService envelopeReceiverService, IEnvelopeHistoryService historyService, IStringLocalizer<Resource> localizer, IConfiguration configuration, HtmlSanitizer sanitizer, Cultures cultures, IEnvelopeMailService envelopeMailService, IEnvelopeReceiverReadOnlyService readOnlyService, IMessagingService messagingService, ICodeGenerator codeGenerator, IReceiverService receiverService)
+        public HomeController(EnvelopeOldService envelopeOldService, ILogger<HomeController> logger, IEnvelopeReceiverService envelopeReceiverService, IEnvelopeHistoryService historyService, IStringLocalizer<Resource> localizer, IConfiguration configuration, HtmlSanitizer sanitizer, Cultures cultures, IEnvelopeMailService envelopeMailService, IEnvelopeReceiverReadOnlyService readOnlyService, IAuthenticator authenticator, IReceiverService receiverService, IEnvelopeSmsHandler envelopeSmsService)
         {
             this.envelopeOldService = envelopeOldService;
             _envRcvService = envelopeReceiverService;
@@ -53,9 +51,9 @@ namespace EnvelopeGenerator.Web.Controllers
             _mailService = envelopeMailService;
             _logger = logger;
             _readOnlyService = readOnlyService;
-            _msgService = messagingService;
-            _codeGenerator = codeGenerator;
+            _authenticator = authenticator;
             _rcvService = receiverService;
+            _envSmsHandler = envelopeSmsService;
         }
 
         [HttpGet("/")]
@@ -162,6 +160,91 @@ namespace EnvelopeGenerator.Web.Controllers
             }
         }
 
+        #region TFA Views
+        [NonAction]
+        private async Task<IActionResult> TFAViewAsync(bool viaSms, EnvelopeReceiverSecretDto er_secret, string envelopeReceiverId)
+        {
+            if (viaSms)
+            {
+                var (smsRes, expiration) = await _envSmsHandler.SendTotpAsync(er_secret);
+
+                if (smsRes is not null && smsRes.Failed)
+                {
+                    var res_json = JsonConvert.SerializeObject(smsRes);
+                    _logger.LogEnvelopeError(envelopeReceiverId: envelopeReceiverId, message: $"An unexpected error occurred while sending an SMS code. Response: ${res_json}");
+                    return this.ViewInnerServiceError();
+                }
+
+                return View("EnvelopeLocked").WithData("CodeType", "smsCode").WithData("SmsExpiration", expiration);
+            }
+            else
+            {
+                return View("EnvelopeLocked").WithData("CodeType", "authenticatorCode").WithData("QRCodeExpiration", er_secret.Receiver?.TotpExpiration);
+            }
+        }
+
+        [NonAction]
+        private async Task<IActionResult?> HandleAccessCodeAsync(Auth auth, EnvelopeReceiverSecretDto er_secret, string envelopeReceiverId)
+        {
+            //check the access code verification
+            if (er_secret.AccessCode != auth.AccessCode)
+            {
+                //Constants.EnvelopeStatus.AccessCodeIncorrect
+                await _historyService.RecordAsync(er_secret.EnvelopeId, er_secret.Receiver!.EmailAddress, EnvelopeStatus.AccessCodeIncorrect);
+                Response.StatusCode = StatusCodes.Status401Unauthorized;
+                return View("EnvelopeLocked")
+                        .WithData("ErrorMessage", _localizer[WebKey.WrongAccessCode].Value);
+            }
+
+            await _historyService.RecordAsync(er_secret.EnvelopeId, er_secret.Receiver!.EmailAddress, EnvelopeStatus.AccessCodeCorrect);
+
+            //check if the user has phone is added
+            if (er_secret.Envelope!.TFAEnabled)
+            {
+                var rcv = er_secret.Receiver;
+                if (rcv.IsTotpSecretInvalid())
+                {
+                    rcv.TotpSecretkey = _authenticator.GenerateTotpSecretKey();
+                    rcv.TotpExpiration = DateTime.Now.AddMonths(1);
+                    await _rcvService.UpdateAsync(rcv);
+                    await _mailService.SendTFAQrCodeAsync(er_secret);
+                }
+                return await TFAViewAsync(auth.UserSelectSMS, er_secret, envelopeReceiverId);
+            }
+
+            return null;
+        }
+
+        [NonAction]
+        private async Task<IActionResult?> HandleSmsAsync(Auth auth, EnvelopeReceiverSecretDto er_secret, string envelopeReceiverId)
+        {
+            if (er_secret.Receiver!.TotpSecretkey is null)
+                throw new InvalidOperationException($"TotpSecretkey of DTO cannot validate without TotpSecretkey. Dto: {JsonConvert.SerializeObject(er_secret)}");
+            
+            if (_envSmsHandler.VerifyTotp(auth.SmsCode!, er_secret.Receiver.TotpSecretkey))
+            {
+                Response.StatusCode = StatusCodes.Status401Unauthorized;
+                ViewData["ErrorMessage"] = _localizer[WebKey.WrongAccessCode].Value;
+                return await TFAViewAsync(viaSms: true, er_secret, envelopeReceiverId);
+            }
+
+            return null;
+        }
+
+        [NonAction]
+        private async Task<IActionResult?> HandleAuthenticatorAsync(Auth auth, EnvelopeReceiverSecretDto er_secret, string envelopeReceiverId)
+        {
+            if (er_secret.Receiver!.IsTotpInvalid(totp: auth.AuthenticatorCode!))
+            {
+                Response.StatusCode = StatusCodes.Status401Unauthorized;
+                ViewData["ErrorMessage"] = _localizer[WebKey.WrongAccessCode].Value;
+                return await TFAViewAsync(viaSms: false, er_secret, envelopeReceiverId);
+            }
+
+            return null;
+        }
+        #endregion
+
         [HttpPost("EnvelopeKey/{envelopeReceiverId}/Locked")]
         public async Task<IActionResult> LogInEnvelope([FromRoute] string envelopeReceiverId, [FromForm] Auth auth)
         {
@@ -192,29 +275,6 @@ namespace EnvelopeGenerator.Web.Controllers
                 }
                 var er_secret = er_secret_res.Data;
 
-                async Task<IActionResult> TFAView(bool viaSms)
-                {
-                    if (viaSms)
-                    {
-                        //add date time cache
-                        var res = await _msgService.SendSmsCodeAsync(er_secret.PhoneNumber!, er_secret.Receiver!.TotpSecretkey!, SmsFormat);
-                        if (res.Ok)
-                            return View("EnvelopeLocked").WithData("CodeType", "smsCode").WithData("SmsExpiration", _codeGenerator.GetTotpExpirationTime(SmsTotpStep));
-                        else if (!res.Allowed)
-                            return View("EnvelopeLocked").WithData("CodeType", "smsCode").WithData("SmsExpiration", res.AllowedAt);
-                        else
-                        {
-                            var res_json = JsonConvert.SerializeObject(res);
-                            _logger.LogEnvelopeError(envelopeReceiverId: envelopeReceiverId, message: $"An unexpected error occurred while sending an SMS code. Response: ${res_json}");
-                            return this.ViewInnerServiceError();
-                        }
-                    }
-                    else
-                    {
-                        return View("EnvelopeLocked").WithData("CodeType", "authenticatorCode").WithData("QRCodeExpiration", er_secret.Receiver?.TotpExpiration);
-                    }
-                }
-
                 if (auth.HasMulti)
                 {
                     Response.StatusCode = StatusCodes.Status401Unauthorized;
@@ -222,55 +282,14 @@ namespace EnvelopeGenerator.Web.Controllers
                             .WithData("ErrorMessage", _localizer[WebKey.WrongAccessCode].Value);
                 }
                 else if (auth.HasAccessCode)
-                {
-                    //check the access code verification
-                    if (er_secret.AccessCode != auth.AccessCode)
-                    {
-                        //Constants.EnvelopeStatus.AccessCodeIncorrect
-                        await _historyService.RecordAsync(er_secret.EnvelopeId, er_secret.Receiver!.EmailAddress, EnvelopeStatus.AccessCodeIncorrect);
-                        Response.StatusCode = StatusCodes.Status401Unauthorized;
-                        return View("EnvelopeLocked")
-                                .WithData("ErrorMessage", _localizer[WebKey.WrongAccessCode].Value);
-                    }
-
-                    await _historyService.RecordAsync(er_secret.EnvelopeId, er_secret.Receiver!.EmailAddress, EnvelopeStatus.AccessCodeCorrect);
-
-                    //check if the user has phone is added
-                    if (er_secret.Envelope!.TFAEnabled)
-                    {
-                        var rcv = er_secret.Receiver;
-                        if (rcv.IsTotpSecretInvalid())
-                        {
-                            rcv.TotpSecretkey = _codeGenerator.GenerateTotpSecretKey();
-                            rcv.TotpExpiration = DateTime.Now.AddMonths(1);
-                            await _rcvService.UpdateAsync(rcv);
-                            await _mailService.SendTFAQrCodeAsync(er_secret);
-                        }
-                        return await TFAView(auth.UserSelectSMS);
-                    }
-
-                }
+                    if(await HandleAccessCodeAsync(auth, er_secret, envelopeReceiverId) is IActionResult acView)
+                        return acView;
                 else if (auth.HasSmsCode)
-                {
-                    if (er_secret.Receiver!.TotpSecretkey is null)
-                        throw new InvalidOperationException($"TotpSecretkey of DTO cannot validate without TotpSecretkey. Dto: {JsonConvert.SerializeObject(er_secret)}");
-
-                    if (_codeGenerator.VerifyTotp(auth.SmsCode!, er_secret.Receiver.TotpSecretkey, step: SmsTotpStep))
-                    {
-                        Response.StatusCode = StatusCodes.Status401Unauthorized;
-                        ViewData["ErrorMessage"] = _localizer[WebKey.WrongAccessCode].Value;
-                        return await TFAView(viaSms: true);
-                    }
-                }
+                    if(await HandleSmsAsync(auth, er_secret, envelopeReceiverId) is IActionResult smsView)
+                        return smsView;
                 else if (auth.HasAuthenticatorCode)
-                {
-                    if (er_secret.Receiver!.IsTotpInvalid(totp: auth.AuthenticatorCode!))
-                    {
-                        Response.StatusCode = StatusCodes.Status401Unauthorized;
-                        ViewData["ErrorMessage"] = _localizer[WebKey.WrongAccessCode].Value;
-                        return await TFAView(viaSms: false);
-                    }
-                }
+                    if(await HandleAuthenticatorAsync(auth, er_secret, envelopeReceiverId) is IActionResult aView)
+                        return aView;
                 else
                 {
                     Response.StatusCode = StatusCodes.Status401Unauthorized;

EnvelopeGenerator.Web/Controllers/Test/TestAuthController.cs

@@ -1,42 +0,0 @@
-using EnvelopeGenerator.Application.Contracts;
-using EnvelopeGenerator.Application.Services;
-using Microsoft.AspNetCore.Authorization;
-using Microsoft.AspNetCore.Mvc;
-using System.Security.Claims;
-
-namespace EnvelopeGenerator.Web.Controllers.Test
-{
-    [ApiController]
-    [Route("api/test/[controller]")]
-    public class TestAuthController : ControllerBase
-    {
-        private readonly IJWTService<string> _authService;
-
-        public TestAuthController(IJWTService<string> authService)
-        {
-            _authService = authService;
-        }
-
-        [HttpPost]
-        public IActionResult ProvideToken([FromQuery] string value)
-        {
-            var token = _authService.GenerateToken(value);
-            return Ok(token);
-        }
-
-        [HttpGet]
-        public IActionResult GetSecurityToken([FromQuery] string token)
-        {
-            var sToken = _authService.ReadSecurityToken(token);
-            return Ok(sToken);
-        }
-
-        [HttpGet("Username")]
-        [Authorize]
-        public IActionResult Getname()
-        {
-            var username = User.Claims?.FirstOrDefault(c => c.Type == ClaimTypes.Name)?.Value;
-            return Ok(username);
-        }
-    }
-}

EnvelopeGenerator.Web/Controllers/Test/TestMessagingController.cs

@@ -7,9 +7,9 @@ namespace EnvelopeGenerator.Web.Controllers.Test
     [ApiController]
     public class TestMessagingController : ControllerBase
     {
-        private readonly IMessagingService _service;
+        private readonly ISmsSender _service;
 
-        public TestMessagingController(IMessagingService service)
+        public TestMessagingController(ISmsSender service)
         {
             _service = service;
         }

EnvelopeGenerator.Web/EnvelopeGenerator.Web.csproj

@@ -5,7 +5,7 @@
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
     <PackageId>EnvelopeGenerator.Web</PackageId>
-    <Version>2.8.2</Version>
+    <Version>2.9.0</Version>
     <Authors>Digital Data GmbH</Authors>
     <Company>Digital Data GmbH</Company>
     <Product>EnvelopeGenerator.Web</Product>
@@ -13,8 +13,8 @@
     <PackageTags>digital data envelope generator web</PackageTags>
     <Description>EnvelopeGenerator.Web is an ASP.NET MVC application developed to manage signing processes. It uses Entity Framework Core (EF Core) for database operations. The user interface for signing processes is developed with Razor View Engine (.cshtml files) and JavaScript under wwwroot, integrated with PSPDFKit. This integration allows users to view and sign documents seamlessly.</Description>
     <ApplicationIcon>Assets\icon.ico</ApplicationIcon>
-    <AssemblyVersion>2.8.1</AssemblyVersion>
-    <FileVersion>2.8.1</FileVersion>
+    <AssemblyVersion>2.9.0</AssemblyVersion>
+    <FileVersion>2.9.0</FileVersion>
     <Copyright>Copyright © 2024 Digital Data GmbH. All rights reserved.</Copyright>
   </PropertyGroup>
 

EnvelopeGenerator.Web/appsettings.json

@@ -70,11 +70,6 @@
       }
     ]
   },
-  "Jwt": {
-    "Issuer": null,
-    "Audience": null,
-    "Key": "8RGnd7x0G2TYLOIW4m_qlIls7MfbAIGNrpQJzMAUIvULHOLiG723znRa_MG-Z4yw3SErusOU4hTui2rVBMcCaQ"
-  },
   "ContactLink": {
     "Label": "Kontakt",
     "Href": "https://digitaldata.works/",
@@ -113,30 +108,25 @@
     "ShowPageClass": "dd-show-logo",
     "LockedPageClass": "dd-locked-logo"
   },
-  "DispatcherConfig": {
+  "DispatcherParams": {
     "SendingProfile": 1,
     "AddedWho": "DDEnvelopGenerator",
     "ReminderTypeId": 202377,
     "EmailAttmt1": ""
   },
-  "MailConfig": {
+  "MailParams": {
     "Placeholders": {
       "[NAME_PORTAL]": "signFlow",
       "[SIGNATURE_TYPE]": "signieren",
       "[REASON]": ""
     }
   },
-  "GTXMessagingConfig": {
-    "AuthKey": "ep$?A!Gs"
-  },
-  "SmsConfig": {
+  "GtxMessagingParams": {
     "Uri": "https://rest.gtx-messaging.net",
     "Path": "smsc/sendsms/f566f7e5-bdf2-4a9a-bf52-ed88215a432e/json",
     "Headers": {},
     "QueryParams": {
       "from": "signFlow"
-    },
-    "CodeCacheValidityPeriod": "00:10:00"
-  },
-  "EnvelopeReceiverCacheParams": {}
+    }
+  }
 }