reeplace cerberos by talos

Core.Thalos.Infraestructure/Caching/CacheHelper.cs

@@ -0,0 +1,30 @@
+using Core.Thalos.Infraestructure.Caching.Configs;
+
+namespace LSA.Core.Dapper.Service.Caching
+{
+    public static class CacheHelper
+    {
+        /// <summary>
+        /// Determines the cache duration based on specific duration, settings, or a default value.
+        /// </summary>
+        /// <param name="specificCacheDuration">Specific cache duration in minutes, if provided.</param>
+        /// <param name="cacheSettings">General cache settings containing default duration values.</param>
+        /// <returns>The cache duration as a TimeSpan.</returns>
+        public static TimeSpan GetCacheDuration(CacheSettings cacheSettings, int? specificCacheDuration = 0)
+        {
+            var defaultCacheDuration = TimeSpan.FromMinutes(.5);
+
+            if (specificCacheDuration.HasValue && specificCacheDuration.Value > 0)
+            {
+                return TimeSpan.FromMinutes(specificCacheDuration.Value);
+            }
+
+            if (cacheSettings.DefaultCacheDurationInMinutes > 0)
+            {
+                return TimeSpan.FromMinutes(cacheSettings.DefaultCacheDurationInMinutes);
+            }
+
+            return defaultCacheDuration;
+        }
+    }
+}

Core.Thalos.Infraestructure/Caching/CacheKeyHelper.cs

@@ -0,0 +1,47 @@
+using System.Reflection;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace LSA.Core.Dapper.Service.Caching
+{
+    public static class CacheKeyHelper
+    {
+        public static string GenerateCacheKey(object instance, string methodName, params object[] parameters)
+        {
+            var className = instance.GetType().Name;
+            var keyBuilder = new StringBuilder($"{className}.{methodName}");
+
+            foreach (var param in parameters)
+            {
+                string normalizedParam = NormalizeParameter(param);
+                keyBuilder.Append($".{normalizedParam}");
+            }
+
+            return keyBuilder.ToString();
+        }
+
+        private static string NormalizeParameter(object param)
+        {
+            if (param == null)
+            {
+                return "null";
+            }
+
+            string paramString;
+
+            if (param is DateTime dateTime)
+            {
+                paramString = dateTime.ToString("yyyyMMdd");
+            }
+            else
+            {
+                paramString = param.ToString();
+            }
+
+            // Replace special characters with an underscore
+            string normalizedParam = Regex.Replace(paramString, @"[^a-zA-Z0-9]", "_");
+
+            return normalizedParam;
+        }
+    }
+}

Core.Thalos.Infraestructure/Caching/CacheService.cs

@@ -0,0 +1,133 @@
+using Azure.Identity;
+using Core.Thalos.Infraestructure.Caching.Contracts;
+using Microsoft.Extensions.Logging;
+using StackExchange.Redis;
+using System.Text.Json;
+
+namespace LSA.Core.Dapper.Service.Caching
+{
+    public class CacheService : ICacheService
+    {
+        private IDatabase _cacheDatabase = null!;
+        private readonly ILogger<CacheService> _logger;
+
+
+        public CacheService(string connectionString, ILogger<CacheService> logger)
+        {
+            _logger = logger;
+            Task.Run(async () =>
+            {
+                _cacheDatabase = await GetRedisDatabase(connectionString);
+            }).Wait();
+        }
+
+        private async Task<IDatabase> GetRedisDatabase(string connectionString)
+        {
+            try
+            {
+                var configurationOptions = await ConfigurationOptions.Parse($"{connectionString}")
+                    .ConfigureForAzureWithTokenCredentialAsync(new DefaultAzureCredential());
+
+                configurationOptions.AbortOnConnectFail = false;
+                var connectionMultiplexer = await ConnectionMultiplexer.ConnectAsync(configurationOptions);
+
+                _logger.LogInformation("Successfully connected to Redis.");
+
+                return connectionMultiplexer.GetDatabase();
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error establishing Redis connection.");
+                throw;
+            }
+        }
+
+
+        public async Task<T> GetAsync<T>(string key)
+        {
+            try
+            {
+                var value = await _cacheDatabase.StringGetAsync(key);
+                if (value.IsNullOrEmpty)
+                {
+                    _logger.LogInformation($"Cache miss for key: {key}");
+                    return default;
+                }
+
+                _logger.LogInformation($"Cache hit for key: {key}");
+                return JsonSerializer.Deserialize<T>(value);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, $"Error getting cache item with key {key}");
+                throw;
+            }
+        }
+
+        public async Task SetAsync<T>(string key, T value, TimeSpan? expiry = null)
+        {
+            try
+            {
+                var json = JsonSerializer.Serialize(value);
+                await _cacheDatabase.StringSetAsync(key, json, expiry);
+                _logger.LogInformation($"Cache item set with key: {key}");
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, $"Error setting cache item with key {key}");
+                throw;
+            }
+        }
+
+        public async Task RemoveAsync(string key)
+        {
+            try
+            {
+                await _cacheDatabase.KeyDeleteAsync(key);
+                _logger.LogInformation($"Cache item removed with key: {key}");
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, $"Error removing cache item with key {key}");
+                throw;
+            }
+        }
+
+        public async Task<bool> ExistsAsync(string key)
+        {
+            try
+            {
+                var exists = await _cacheDatabase.KeyExistsAsync(key);
+                _logger.LogInformation($"Cache item exists check for key: {key} - {exists}");
+                return exists;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, $"Error checking existence of cache item with key {key}");
+                throw;
+            }
+        }
+
+        public async Task RefreshAsync(string key, TimeSpan? expiry = null)
+        {
+            try
+            {
+                var value = await _cacheDatabase.StringGetAsync(key);
+                if (!value.IsNullOrEmpty)
+                {
+                    await _cacheDatabase.StringSetAsync(key, value, expiry);
+                    _logger.LogInformation($"Cache item refreshed with key: {key}");
+                }
+                else
+                {
+                    _logger.LogWarning($"Cache item with key: {key} does not exist, cannot refresh");
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, $"Error refreshing cache item with key {key}");
+                throw;
+            }
+        }
+    }
+}

Core.Thalos.Infraestructure/Caching/Configs/CacheSettings.cs

@@ -0,0 +1,7 @@
+namespace Core.Thalos.Infraestructure.Caching.Configs
+{
+    public class CacheSettings
+    {
+        public int DefaultCacheDurationInMinutes { get; set; }
+    }
+}

Core.Thalos.Infraestructure/Caching/Contracts/ICacheService.cs

@@ -0,0 +1,11 @@
+namespace Core.Thalos.Infraestructure.Caching.Contracts
+{
+    public interface ICacheService
+    {
+        Task<T> GetAsync<T>(string key);
+        Task SetAsync<T>(string key, T value, TimeSpan? expiry = null);
+        Task RemoveAsync(string key);
+        Task<bool> ExistsAsync(string key);
+        Task RefreshAsync(string key, TimeSpan? expiry = null);
+    }
+}

Core.Thalos.Infraestructure/Contexts/Mongo/ConnectionStringProvider.cs

@@ -0,0 +1,33 @@
+using Microsoft.Extensions.Configuration;
+
+namespace Core.Thalos.Infraestructure.Contexts.Mongo
+{
+    public class ConnectionStringProvider(IConfiguration configuration) : IConnectionStringProvider
+    {
+        public string ConnectionString { get; set; } = string.Empty;
+        public string Databasename { get; set; } = string.Empty;
+        public string Audience { get; set; } = string.Empty;
+
+        public string GetConnectionString()
+        {
+            return configuration?.GetConnectionString("DefaultConnection")?.ToString() ?? string.Empty;
+        }
+        public string GetDatabasename()
+        {
+            return configuration.GetSection("MongoDb:DatabaseName").Value ?? string.Empty;
+        }
+
+        public string GetAudience()
+        {
+            return configuration.GetSection("MongoDb:Audience").Value ?? string.Empty;
+        }
+    }
+    public interface IConnectionStringProvider
+    {
+        string GetConnectionString();
+        string GetDatabasename();
+        string ConnectionString { get; set; }
+        string Databasename { get; set; }
+        string Audience { get; set; }
+    }
+}

Core.Thalos.Infraestructure/Contexts/Mongo/MongoConnSettings.cs

@@ -0,0 +1,14 @@
+namespace Core.Thalos.Infraestructure.Contexts.Mongo;
+
+public interface IMongoConnSettings
+{
+    string ConnectionString { get; set; }
+    string Databasename { get; set; }
+    string Audience { get; set; }
+}
+public class MongoConnSettings : IMongoConnSettings
+{
+    public string ConnectionString { get; set; }
+    public string Databasename { get; set; }
+    public string Audience { get; set; }
+}

Core.Thalos.Infraestructure/Core.Thalos.Infrastructure.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Azure.StackExchangeRedis" Version="3.1.0" />
+    <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="8.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="8.0.0" />
+    <PackageReference Include="StackExchange.Redis" Version="2.8.16" />
+  </ItemGroup>
+
+</Project>

Core.Thalos.Infraestructure/PerformanceCacheService/CacheAttribute.cs

@@ -0,0 +1,15 @@
+namespace Core.Thalos.Infraestructure.PerformanceCacheService
+{
+    [AttributeUsage(AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
+    public class CacheAttribute : Attribute
+    {
+        public int CacheDurationInMinutes { get; set; }
+        public bool EnableCaching { get; set; }
+
+        public CacheAttribute(int cacheDurationInMinutes, bool enableCaching = true)
+        {
+            CacheDurationInMinutes = cacheDurationInMinutes;
+            EnableCaching = enableCaching;
+        }
+    }
+}