feat(EnvelopeReceiverCache): zum Abrufen und Setzen von Caches über Envelope Receiver unter Verwendung von Standard-Schlüsselwörtern als Schnittstellenimplementierung erstellt.

- Erstellte Optionen.
 - Zu DI hinzugefügt.

EnvelopeGenerator.Application/Configurations/EnvelopeReceiverCacheParams.cs

@@ -0,0 +1,19 @@
+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}";
+
+        public TimeSpan CodeCacheValidityPeriod { get; init; } = new(0, 5, 0);
+    }
+}

EnvelopeGenerator.Application/Configurations/GtxMessaging/SmsParams.cs

@@ -21,19 +21,5 @@ namespace EnvelopeGenerator.Application.Configurations.GtxMessaging
         public string MessageQueryParamName { get; init; } = "text";
 
         public int CodeLength { get; init; } = 5;
-
-        /// <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}";
-
-        public TimeSpan CodeCacheValidityPeriod { get; init; } = new(0, 5, 0);
     }
 }

EnvelopeGenerator.Application/Contracts/IEnvelopeReceiverCache.cs

@@ -0,0 +1,17 @@
+namespace EnvelopeGenerator.Application.Contracts
+{
+    public interface IEnvelopeReceiverCache
+    {
+        Task<string?> GetSmsCodeAsync(string envelopeReceiverId);
+
+        /// <summary>
+        /// Asynchronously stores an SMS verification code in the cache and returns the expiration date of the code.
+        /// </summary>
+        /// <param name="envelopeReceiverId">The unique identifier for the recipient of the envelope to associate with the SMS code.</param>
+        /// <param name="code">The SMS verification code to be stored.</param>
+        /// <returns>A task that represents the asynchronous operation. The task result contains the expiration date and time of the stored SMS code.</returns>
+        Task<DateTime> SetSmsCodeAsync(string envelopeReceiverId, string code);
+
+        Task<DateTime?> GetSmsCodeExpirationAsync(string envelopeReceiverId);
+    }
+}

EnvelopeGenerator.Application/Extensions/DIExtensions.cs

@@ -15,7 +15,7 @@ namespace EnvelopeGenerator.Application.Extensions
 {
     public static class DIExtensions
     {
-        public static IServiceCollection AddEnvelopeGenerator(this IServiceCollection services, IConfigurationSection dispatcherConfigSection, IConfigurationSection mailConfigSection, IConfigurationSection smsConfigSection, IConfigurationSection codeGeneratorConfigSection)
+        public static IServiceCollection AddEnvelopeGenerator(this IServiceCollection services, IConfigurationSection dispatcherConfigSection, IConfigurationSection mailConfigSection, IConfigurationSection smsConfigSection, IConfigurationSection codeGeneratorConfigSection, IConfigurationSection envelopeReceiverCacheParamsSection)
         {
             //Inject CRUD Service and repositoriesad
             services.TryAddScoped<IConfigRepository, ConfigRepository>();
@@ -56,10 +56,12 @@ namespace EnvelopeGenerator.Application.Extensions
             services.Configure<DispatcherConfig>(dispatcherConfigSection);
             services.Configure<MailConfig>(mailConfigSection);
             services.Configure<CodeGeneratorConfig>(codeGeneratorConfigSection);
+            services.Configure<EnvelopeReceiverCacheParams>(envelopeReceiverCacheParamsSection);
 
             services.AddHttpClientService<SmsParams>(smsConfigSection);
             services.TryAddSingleton<IMessagingService, GtxMessagingService>();
             services.TryAddSingleton<ICodeGenerator, CodeGenerator>();
+            services.TryAddSingleton<IEnvelopeReceiverCache, EnvelopeReceiverCache>();
 
             return services;
         }
@@ -68,6 +70,7 @@ namespace EnvelopeGenerator.Application.Extensions
             dispatcherConfigSection: config.GetSection("DispatcherConfig"),
             mailConfigSection: config.GetSection("MailConfig"),
             smsConfigSection: config.GetSection("SmsConfig"),
-            codeGeneratorConfigSection: config.GetSection("CodeGeneratorConfig"));
+            codeGeneratorConfigSection: config.GetSection("CodeGeneratorConfig"),
+            envelopeReceiverCacheParamsSection: config.GetSection("EnvelopeReceiverCacheParams"));
     }
 }

EnvelopeGenerator.Application/Services/EnvelopeReceiverCache.cs

@@ -0,0 +1,50 @@
+using AngleSharp.Dom;
+using EnvelopeGenerator.Application.Configurations;
+using EnvelopeGenerator.Application.Contracts;
+using EnvelopeGenerator.Application.Extensions;
+using Microsoft.Extensions.Caching.Distributed;
+using Microsoft.Extensions.Options;
+
+namespace EnvelopeGenerator.Application.Services
+{
+    public class EnvelopeReceiverCache : IEnvelopeReceiverCache
+    {
+        private readonly EnvelopeReceiverCacheParams _cacheParams;
+
+        private readonly DistributedCacheEntryOptions _codeCacheOptions;
+
+        private readonly IDistributedCache _cache;
+
+        public EnvelopeReceiverCache(IOptions<EnvelopeReceiverCacheParams> cacheParamOptions, IDistributedCache cache)
+        {
+            _cacheParams = cacheParamOptions.Value;
+            _codeCacheOptions = new() { AbsoluteExpirationRelativeToNow = cacheParamOptions.Value.CodeCacheValidityPeriod };
+            _cache = cache;
+        }
+
+        public async Task<string?> GetSmsCodeAsync(string envelopeReceiverId)
+        {
+            var code_key = string.Format(_cacheParams.CodeCacheKeyFormat, envelopeReceiverId);
+            return await _cache.GetStringAsync(code_key);
+        }
+
+        public async Task<DateTime> SetSmsCodeAsync(string envelopeReceiverId, string code)
+        {
+            // set key
+            var code_key = string.Format(_cacheParams.CodeCacheKeyFormat, envelopeReceiverId);
+            await _cache.SetStringAsync(code_key, code, _codeCacheOptions);
+
+            // set expiration
+            var code_expiration_key = string.Format(_cacheParams.CodeExpirationCacheKeyFormat, envelopeReceiverId);
+            var expiration = DateTime.Now + _cacheParams.CodeCacheValidityPeriod;
+            await _cache.SetDateTimeAsync(code_expiration_key, expiration, _codeCacheOptions);
+            return expiration;
+        }
+
+        public async Task<DateTime?> GetSmsCodeExpirationAsync(string envelopeReceiverId)
+        {
+            var code_expiration_key = string.Format(_cacheParams.CodeExpirationCacheKeyFormat, envelopeReceiverId);
+            return await _cache.GetDateTimeAsync(code_expiration_key);
+        }
+    }
+}

EnvelopeGenerator.Application/Services/GTXMessagingService.cs

@@ -21,21 +21,18 @@ namespace EnvelopeGenerator.Application.Services
 
         private readonly ICodeGenerator _codeGen;
 
-        private readonly IDistributedCache _cache;
+        private readonly IEnvelopeReceiverCache _erCache;
 
         public string ServiceProvider { get; }
 
-        private readonly DistributedCacheEntryOptions _codeCacheOptions;
+        public GtxMessagingService(IHttpClientService<SmsParams> smsClient, IOptions<SmsParams> smsParamsOptions, IMapper mapper, ICodeGenerator codeGenerator, IEnvelopeReceiverCache envelopeReceiverCache)
-
-        public GtxMessagingService(IHttpClientService<SmsParams> smsClient, IOptions<SmsParams> smsParamsOptions, IMapper mapper, ICodeGenerator codeGenerator, IDistributedCache distributedCache)
         {
             _smsClient = smsClient;
             _smsParams = smsParamsOptions.Value;
             _mapper = mapper;
             ServiceProvider = GetType().Name.Replace("Service", string.Empty);
             _codeGen = codeGenerator;
-            _cache = distributedCache;
+            _erCache = envelopeReceiverCache;
-            _codeCacheOptions = new() { AbsoluteExpirationRelativeToNow = smsParamsOptions.Value.CodeCacheValidityPeriod };
         }
 
         public async Task<SmsResponse> SendSmsAsync(string recipient, string message)
@@ -51,27 +48,19 @@ namespace EnvelopeGenerator.Application.Services
 
         public async Task<SmsResponse> SendSmsCodeAsync(string recipient, string envelopeReceiverId)
         {
-            var code_expiration_key = string.Format(_smsParams.CodeExpirationCacheKeyFormat, envelopeReceiverId);
+            var code = await _erCache.GetSmsCodeAsync(envelopeReceiverId);
-
-            var code_key = string.Format(_smsParams.CodeCacheKeyFormat, envelopeReceiverId);
-            var code = await _cache.GetStringAsync(code_key);
 
             if (code is null)
             {
                 code = _codeGen.GenerateCode(_smsParams.CodeLength);                                
-                                
+                var expiration = await _erCache.SetSmsCodeAsync(envelopeReceiverId, code);                
-                await _cache.SetStringAsync(code_key, code, _codeCacheOptions);
-
-                var expiration = DateTime.Now + _smsParams.CodeCacheValidityPeriod;
-                await _cache.SetDateTimeAsync(code_expiration_key, expiration, _codeCacheOptions);
-                
                 var res = await SendSmsAsync(recipient: recipient, message: code);
                 res.Expiration = expiration;
                 return res;
             }
             else
             {
-                var code_expiration = await _cache.GetDateTimeAsync(code_expiration_key);
+                var code_expiration = await _erCache.GetSmsCodeExpirationAsync(envelopeReceiverId);
                 return code_expiration is null
                     ? new() { Ok = false }
                     : new() { Ok = false, AllowedAt = code_expiration };

EnvelopeGenerator.Web/appsettings.json

@@ -137,5 +137,6 @@
       "from": "signFlow"
     },
     "CodeCacheValidityPeriod": "00:10:00"
-  }
+  },
+  "EnvelopeReceiverCacheParams": {}
 }