Adapt to create packages

Core.Blueprint.Mongo/Configuration/RegisterBlueprint.cs

@@ -4,6 +4,7 @@ using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 using MongoDB.Driver;
+using static MongoDB.Driver.WriteConcern;
 
 namespace Core.Blueprint.DAL.Mongo.Configuration
 {
@@ -23,42 +24,50 @@ namespace Core.Blueprint.DAL.Mongo.Configuration
         public static IServiceCollection AddMongoLayer(this IServiceCollection services, IConfiguration configuration)
         {
             var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? string.Empty;
-
+            
             services.AddSingleton<IMongoContext, MongoContext>();
+            string ConnectionString = configuration.GetSection("ConnectionStrings:MongoDB").Value ?? string.Empty;
+            string Databasename = configuration.GetSection("MongoDb:DatabaseName").Value ?? string.Empty;
+            string Audience = string.Empty;
 
-            var ConnectionString = configuration.GetSection("ConnectionStrings:MongoDB").Value ?? string.Empty;
-            var Databasename = configuration.GetSection("MongoDb:DatabaseName").Value ?? string.Empty;
-            var Audience = (environment == "Local")
-                ? configuration.GetSection("MongoDb:LocalAudience").Value
-                : configuration.GetSection("MongoDb:Audience").Value;
+            if (!environment.Equals("Local", StringComparison.OrdinalIgnoreCase))
+            {
+                Audience = configuration.GetSection("MongoDb:Audience").Value ?? string.Empty;
+            }
 
-            if (string.IsNullOrEmpty(ConnectionString) || string.IsNullOrEmpty(Databasename) || string.IsNullOrEmpty(Audience))
+            if (string.IsNullOrEmpty(ConnectionString) || string.IsNullOrEmpty(Databasename))
+            {
                 throw new InvalidOperationException("Mongo connection is not configured correctly.");
+            }
 
-            services.Configure<MongoDbSettings>(options =>
+            services.Configure(delegate (MongoDbSettings options)
             {
                 options.ConnectionString = ConnectionString;
                 options.Databasename = Databasename;
-                options.Audience = Audience;
-            });
 
-            services.AddSingleton<IMongoClient>(serviceProvider =>
+                if (!environment.Equals("Local", StringComparison.OrdinalIgnoreCase))
+                {
+                    options.Audience = Audience;
+                }
+            });
+            services.AddSingleton((Func<IServiceProvider, IMongoClient>)delegate (IServiceProvider serviceProvider)
             {
-                var settings = serviceProvider.GetRequiredService<IOptions<MongoDbSettings>>().Value;
-                var mongoClientSettings = MongoClientSettings.FromConnectionString(settings.ConnectionString);
-                mongoClientSettings.Credential = MongoCredential.CreateOidcCredential(new AzureIdentityProvider(settings.Audience));
+                MongoDbSettings value2 = serviceProvider.GetRequiredService<IOptions<MongoDbSettings>>().Value;
+                MongoClientSettings mongoClientSettings = MongoClientSettings.FromConnectionString(value2.ConnectionString);
+
+                if (!environment.Equals("Local", StringComparison.OrdinalIgnoreCase)) 
+                {
+                    mongoClientSettings.Credential = MongoCredential.CreateOidcCredential(new AzureIdentityProvider(value2.Audience));
+                }
+                    
                 return new MongoClient(mongoClientSettings);
             });
-
-            services.AddSingleton<IMongoDatabase>(serviceProvider =>
+            services.AddSingleton(delegate (IServiceProvider serviceProvider)
             {
-                var settings = serviceProvider.GetRequiredService<IOptions<MongoDbSettings>>().Value;
-                var client = serviceProvider.GetRequiredService<IMongoClient>();
-                return client.GetDatabase(settings.Databasename);
+                MongoDbSettings value = serviceProvider.GetRequiredService<IOptions<MongoDbSettings>>().Value;
+                return serviceProvider.GetRequiredService<IMongoClient>().GetDatabase(value.Databasename);
             });
-
-            services.AddSingleton<IMongoDbSettings>(serviceProvider => serviceProvider.GetRequiredService<IOptions<MongoDbSettings>>().Value);
-
+            services.AddSingleton((Func<IServiceProvider, IMongoDbSettings>)((IServiceProvider serviceProvider) => serviceProvider.GetRequiredService<IOptions<MongoDbSettings>>().Value));
             return services;
         }
     }

Core.Blueprint.Mongo/nuget.config

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+	<packageSources>
+		<add key="Gitea" value="https://gitea.white-enciso.pro/api/packages/AgileWebs/nuget" />
+	</packageSources>
+	<packageSourceCredentials>
+		<Gitea>
+			<Username>oscarmmtz</Username>
+			<ClearTextPassword>544831e1ceaf52958e02c5de4d23cbde9e7a860a</ClearTextPassword>
+		</Gitea>
+	</packageSourceCredentials>
+</configuration>

Core.Blueprint.Redis/Configuration/RegisterBlueprint.cs

@@ -21,8 +21,6 @@ namespace Core.Blueprint.Caching.Configuration
         {
             // TODO for the following variable we'll need to add in the appsettings.json the following config: "UseRedisCache": true,
             bool useRedis = configuration.GetValue<bool>("UseRedisCache");
-            //TODO decide wheter to use appsettings or the following ENV variable
-            useRedis = Environment.GetEnvironmentVariable("CORE_BLUEPRINT_PACKAGES_USE_REDIS")?.ToLower() == "true";
 
             if (useRedis)
             {

Core.Blueprint.Redis/Core.Blueprint.Caching.csproj

@@ -4,6 +4,7 @@
     <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
+	<PackageId>Core.Blueprint.Redis</PackageId>
   </PropertyGroup>
 
   <ItemGroup>

Core.Blueprint.Redis/RedisCacheProvider.cs

@@ -35,14 +35,29 @@ namespace Core.Blueprint.Caching
         /// <param name="connectionString">The Redis connection string.</param>
         /// <returns>An <see cref="IDatabase"/> instance representing the Redis cache database.</returns>
         /// <exception cref="Exception">Thrown when the connection to Redis fails.</exce
-        async Task<IDatabase> InitializeRedisAsync(string connectionString)
+        public async Task<IDatabase> InitializeRedisAsync(string connectionString)
         {
             try
             {
-                var configurationOptions = await ConfigurationOptions.Parse($"{connectionString}")
-                    .ConfigureForAzureWithTokenCredentialAsync(new DefaultAzureCredential());
+                var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? string.Empty;
+
+                ConfigurationOptions configurationOptions;
+
+                if (environment.Equals("Local", StringComparison.OrdinalIgnoreCase))
+                {
+                    // Use simple local Redis config
+                    configurationOptions = ConfigurationOptions.Parse(connectionString);
+                }
+                else
+                {
+                    // Use Azure Redis config
+                    configurationOptions = await ConfigurationOptions
+                        .Parse(connectionString)
+                        .ConfigureForAzureWithTokenCredentialAsync(new DefaultAzureCredential());
+                }
 
                 configurationOptions.AbortOnConnectFail = false;
+
                 var connectionMultiplexer = await ConnectionMultiplexer.ConnectAsync(configurationOptions);
 
                 _logger.LogInformation("Successfully connected to Redis.");

Core.Blueprint.Storage/Configuration/RegisterBlueprint.cs

@@ -11,37 +11,23 @@ namespace Core.Blueprint.Storage.Configuration
     {
         public static IServiceCollection AddBlobStorage(this IServiceCollection services, IConfiguration configuration)
         {
+
             var blobConnection = configuration.GetConnectionString("BlobStorage");
 
-            if (string.IsNullOrWhiteSpace(blobConnection))
+            if (blobConnection == null || string.IsNullOrWhiteSpace(blobConnection))
+            {
                 throw new ArgumentException("The BlobStorage configuration section is missing or empty.");
+            }
 
-            var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? string.Empty;
-
+            var chainedCredentials = new ChainedTokenCredential(
+                    new ManagedIdentityCredential(),
+                    new SharedTokenCacheCredential(),
+                    new VisualStudioCredential(),
+                    new VisualStudioCodeCredential()
+                );
             services.AddAzureClients(cfg =>
             {
-                if (environment == "Local")
-                {
-                    var accountKey = configuration.GetSection("BlobStorage:AccountKey").Value;
-                    var accountName = configuration.GetSection("BlobStorage:AccountName").Value;
-
-                    if(string.IsNullOrEmpty(accountKey) && string.IsNullOrEmpty(accountName))
-                        throw new ArgumentException("The BlobStorage configuration section is missing or empty.");
-
-                    cfg.AddBlobServiceClient(configuration.GetConnectionString("BlobStorage"));
-                }
-                else
-                {
-                    var chainedCredentials = new ChainedTokenCredential(
-                        new ManagedIdentityCredential(),
-                        new SharedTokenCacheCredential(),
-                        new VisualStudioCredential(),
-                        new VisualStudioCodeCredential()
-                    );
-
-                    cfg.AddBlobServiceClient(new Uri(blobConnection))
-                        .WithCredential(chainedCredentials);
-                }
+                cfg.AddBlobServiceClient(new Uri(blobConnection)).WithCredential(chainedCredentials);
             });
 
             services.AddScoped<IBlobStorageProvider, BlobStorageProvider>();

Core.Blueprint.Storage/Contracts/IBlobStorageProvider.cs

@@ -162,7 +162,7 @@ namespace Core.Blueprint.Storage.Contracts
         /// </remarks>
         /// <exception cref="ArgumentNullException">Thrown if <paramref name="blobName"/> is null or empty.</exception>
         /// <exception cref="StorageException">Thrown if there is an issue communicating with the Azure Blob service.</exception>
-        ValueTask<BlobDownloadUriAdapter?> GenerateBlobDownloadUri(string blobName);
+        BlobDownloadUriAdapter GenerateBlobDownloadUri(string blobName);
 
         /// <summary>
         /// Retrieves the hierarchical folder structure.

Core.Blueprint.Storage/Provider/BlobStorageProvider.cs

@@ -1,5 +1,4 @@
 using Azure;
-using Azure.Storage;
 using Azure.Storage.Blobs;
 using Azure.Storage.Blobs.Models;
 using Azure.Storage.Blobs.Specialized;
@@ -7,7 +6,6 @@ using Azure.Storage.Sas;
 using Core.Blueprint.Storage.Adapters;
 using Core.Blueprint.Storage.Contracts;
 using Microsoft.Extensions.Configuration;
-using System.Threading.Tasks;
 
 namespace Core.Blueprint.Storage.Provider
 {
@@ -17,12 +15,10 @@ namespace Core.Blueprint.Storage.Provider
         private readonly BlobContainerClient _blobContainerClient;
         private readonly string _containerName;
         private readonly Trie _trie = new Trie();
-        private readonly IConfiguration _configuration;
 
         public BlobStorageProvider(BlobServiceClient blobServiceClient, IConfiguration configuration)
         {
             _blobServiceClient = blobServiceClient;
-            _configuration = configuration;
             _containerName = configuration.GetSection("BlobStorage:ContainerName").Value ?? "";
 
             if (string.IsNullOrEmpty(_containerName))
@@ -282,8 +278,7 @@ namespace Core.Blueprint.Storage.Provider
         /// </summary>
         /// <param name="blobName">The name of the blob for which the download URI is being generated.</param>
         /// <returns>
-        /// An instance of <see cref="BlobDownloadUriAdapter"/> containing the generated URI, blob name, and status,
-        /// or <c>null</c> if the blob does not exist.
+        /// An instance of <see cref="BlobDownloadUriAdapter"/> containing the generated URI, blob name, and status.
         /// </returns>
         /// <remarks>
         /// The generated URI includes a Shared Access Signature (SAS) token, which allows secure, time-limited access to the blob.
@@ -291,36 +286,22 @@ namespace Core.Blueprint.Storage.Provider
         /// </remarks>
         /// <exception cref="ArgumentNullException">Thrown if <paramref name="blobName"/> is null or empty.</exception>
         /// <exception cref="StorageException">Thrown if there is an issue communicating with the Azure Blob service.</exception>
-        public async ValueTask<BlobDownloadUriAdapter?> GenerateBlobDownloadUri(string blobName)
+        public BlobDownloadUriAdapter GenerateBlobDownloadUri(string blobName)
         {
-            if (string.IsNullOrWhiteSpace(blobName))
-                throw new ArgumentNullException(nameof(blobName), "Blob name cannot be null or empty.");
+            var delegationKey = _blobServiceClient.GetUserDelegationKey(DateTimeOffset.UtcNow,
+                                                                    DateTimeOffset.UtcNow.AddHours(2));
 
             var blob = _blobContainerClient.GetBlobClient(blobName);
 
-            if (!await blob.ExistsAsync())
-                return null;
-
-            var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? string.Empty;
-
-            if (environment == "Local")
-            {
-                return GenerateDownloadUri(blob);
-            }
-
-            var delegationKey = await _blobServiceClient.GetUserDelegationKeyAsync(
-                DateTimeOffset.UtcNow,
-                DateTimeOffset.UtcNow.AddHours(2));
-
-            var sasBuilder = new BlobSasBuilder
+            var sasBuilder = new BlobSasBuilder()
             {
                 BlobContainerName = blob.BlobContainerName,
                 BlobName = blob.Name,
                 Resource = "b",
                 StartsOn = DateTimeOffset.UtcNow,
-                ExpiresOn = DateTimeOffset.UtcNow.AddMinutes(5)
+                ExpiresOn = DateTimeOffset.UtcNow.AddMinutes(5),
             };
-            sasBuilder.SetPermissions(BlobSasPermissions.Read);
+            sasBuilder.SetPermissions(BlobAccountSasPermissions.Read);
             sasBuilder.Protocol = SasProtocol.Https;
 
             var blobUriBuilder = new BlobUriBuilder(blob.Uri)
@@ -336,45 +317,6 @@ namespace Core.Blueprint.Storage.Provider
             };
         }
 
-
-        /// <summary>
-        /// Generates a download URI for a blob using a Shared Access Signature in local (Azurite) environment.
-        /// </summary>
-        /// <param name="blob">The blob client for which the URI is being generated.</param>
-        /// <returns>An instance of <see cref="BlobDownloadUriAdapter"/> containing the SAS URI and metadata.</returns>
-        private BlobDownloadUriAdapter GenerateDownloadUri(BlobClient blob)
-        {
-            var sasBuilder = new BlobSasBuilder
-            {
-                BlobContainerName = blob.BlobContainerName,
-                BlobName = blob.Name,
-                Resource = "b",
-                StartsOn = DateTimeOffset.UtcNow,
-                ExpiresOn = DateTimeOffset.UtcNow.AddMinutes(5)
-            };
-            sasBuilder.SetPermissions(BlobSasPermissions.Read);
-            sasBuilder.Protocol = SasProtocol.HttpsAndHttp;
-
-            var accountName = _configuration["BlobStorage:AccountName"];
-            var accountKey = _configuration["BlobStorage:AccountKey"];
-
-            var storageCredentials = new StorageSharedKeyCredential(accountName, accountKey);
-            var sasToken = sasBuilder.ToSasQueryParameters(storageCredentials);
-
-            var blobUriBuilder = new BlobUriBuilder(blob.Uri)
-            {
-                Sas = sasToken
-            };
-
-            return new BlobDownloadUriAdapter
-            {
-                Uri = blobUriBuilder.ToUri(),
-                Name = blob.Name,
-                Status = "Available"
-            };
-        }
-
-
         /// <summary>
         /// Retrieves the hierarchical folder structure.
         /// </summary>